XPSified

unused for now

.github/workflows/update-site.yml

@@ -0,0 +1,24 @@
+name: Update Website
+
+on:
+  # release:
+  #   types:
+  #     - released
+
+  workflow_dispatch:
+
+jobs:
+  trigger:
+    name: Trigger site build
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/github-script@v7
+      with:
+        github-token: ${{ secrets.GEODE_BOT_PUSH_BIN_TOKEN }}
+        script: |
+          await github.rest.actions.createWorkflowDispatch({
+            owner: 'geode-sdk',
+            repo: 'website',
+            workflow_id: 'build.yml',
+            ref: 'main'
+          })

.gitignore

@@ -9,4 +9,5 @@
 .cxx
 local.properties
 app/release/
-.vscode/
+.vscode/
+.kotlin/

app/build.gradle.kts

@@ -1,21 +1,27 @@
-val composeCompiler: String by rootProject.extra
 val composeBOM: String by rootProject.extra
 
+kotlin {
+    compilerOptions {
+        extraWarnings.set(true)
+    }
+}
+
 plugins {
     id("com.android.application")
     id("org.jetbrains.kotlin.android")
     id("org.jetbrains.kotlin.plugin.serialization")
+    id("org.jetbrains.kotlin.plugin.compose")
 }
 
 android {
-    compileSdk = 34
+    compileSdk = 35
 
     defaultConfig {
-        applicationId = "com.geode.launcher"
-        minSdk = 23
-        targetSdk = 34
-        versionCode = 13
-        versionName = "1.3.1"
+        applicationId = "com.geode.launcherXps"
+        minSdk = 26
+        targetSdk = 35
+        versionCode = 1
+        versionName = "1.0.0"
 
         vectorDrawables {
             useSupportLibrary = true
@@ -24,7 +30,7 @@ android {
         @Suppress("UnstableApiUsage")
         externalNativeBuild {
             cmake {
-                arguments("-DUSE_TULIPHOOK:BOOL=OFF")
+                arguments("-DUSE_TULIPHOOK:BOOL=OFF", "-DANDROID_STL=c++_shared")
             }
         }
 
@@ -46,8 +52,13 @@ android {
 
     buildTypes {
         release {
-            isMinifyEnabled = false
-            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
+            isMinifyEnabled = true
+            isShrinkResources = true
+
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro"
+            )
         }
     }
     compileOptions {
@@ -64,9 +75,6 @@ android {
         compose = true
         buildConfig = true
     }
-    composeOptions {
-        kotlinCompilerExtensionVersion = composeCompiler
-    }
     packaging {
         resources {
             excludes += "/META-INF/{AL2.0,LGPL2.1}"
@@ -78,26 +86,28 @@ android {
         }
     }
     namespace = "com.geode.launcher"
-    ndkVersion = "26.1.10909125"
+    ndkVersion = "27.2.12479018"
 }
 
 dependencies {
     implementation (platform("androidx.compose:compose-bom:$composeBOM"))
-    implementation ("androidx.core:core-ktx:1.12.0")
+    implementation ("androidx.core:core-ktx:1.15.0")
     implementation ("androidx.compose.ui:ui")
     implementation ("androidx.compose.material3:material3")
     implementation ("androidx.compose.ui:ui-tooling-preview")
-    implementation ("androidx.lifecycle:lifecycle-runtime-ktx:2.7.0")
-    implementation ("androidx.lifecycle:lifecycle-viewmodel-compose:2.7.0")
-    implementation ("androidx.activity:activity-compose:1.8.2")
-    implementation ("androidx.activity:activity-ktx:1.8.2")
-    implementation ("androidx.appcompat:appcompat:1.6.1")
+    implementation ("androidx.lifecycle:lifecycle-runtime-ktx:2.8.7")
+    implementation ("androidx.lifecycle:lifecycle-viewmodel-compose:2.8.7")
+    implementation ("androidx.activity:activity-compose:1.10.0")
+    implementation ("androidx.activity:activity-ktx:1.10.0")
+    implementation ("androidx.appcompat:appcompat:1.7.0")
     implementation ("androidx.documentfile:documentfile:1.0.1")
-    implementation ("com.squareup.okio:okio:3.8.0")
+    implementation ("com.squareup.okio:okio:3.10.2")
     implementation ("com.squareup.okhttp3:okhttp:4.12.0")
-    implementation ("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.3")
-    implementation ("org.jetbrains.kotlinx:kotlinx-serialization-json-okio:1.6.3")
-    implementation ("org.jetbrains.kotlinx:kotlinx-datetime:0.5.0")
+    implementation ("org.jetbrains.kotlinx:kotlinx-serialization-json:1.8.0")
+    implementation ("org.jetbrains.kotlinx:kotlinx-serialization-json-okio:1.8.0")
+    implementation ("org.jetbrains.kotlinx:kotlinx-datetime:0.6.1")
+    implementation ("com.mikepenz:multiplatform-markdown-renderer-android:0.30.0")
+    implementation ("com.mikepenz:multiplatform-markdown-renderer-m3:0.30.0")
     debugImplementation ("androidx.compose.ui:ui-tooling")
-    coreLibraryDesugaring ("com.android.tools:desugar_jdk_libs:2.0.4")
+    coreLibraryDesugaring ("com.android.tools:desugar_jdk_libs:2.1.4")
 }

app/proguard-rules.pro

@@ -1,21 +1,7 @@
-# Add project specific ProGuard rules here.
-# You can control the set of applied configuration files using the
-# proguardFiles setting in build.gradle.
-#
-# For more details, see
-#   http://developer.android.com/guide/developing/tools/proguard.html
+# Add wildcard keep rules to all of the library code in use
+-keep class org.fmod.** { *; }
+-keep class org.cocos2dx.lib.** { *; }
+-keep class com.customRobTop.** { *; }
 
-# If your project uses WebView with JS, uncomment the following
-# and specify the fully qualified class name to the JavaScript interface
-# class:
-#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
-#   public *;
-#}
-
-# Uncomment this to preserve the line number information for
-# debugging stack traces.
-#-keepattributes SourceFile,LineNumberTable
-
-# If you keep the line number information, uncomment this to
-# hide the original source file name.
-#-renamesourcefileattribute SourceFile
+# note: if you're going to add more rules, consider the @Keep annotation
+# this should really only be kept to non-custom code

app/src/main/AndroidManifest.xml

@@ -3,21 +3,25 @@
     xmlns:tools="http://schemas.android.com/tools">
 
     <queries>
-        <package android:name="com.robtopx.geometryjump" />
+        <package android:name="xyz.lncvrt.xps0000002200" />
     </queries>
 
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
     <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
-    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"
+    <uses-permission
+        android:name="android.permission.READ_EXTERNAL_STORAGE"
         android:maxSdkVersion="32" />
-    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
+    <uses-permission
+        android:name="android.permission.WRITE_EXTERNAL_STORAGE"
         android:maxSdkVersion="32" />
     <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE" />
     <uses-permission android:name="android.permission.READ_MEDIA_AUDIO" />
     <uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
     <uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />
     <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES"/>
+    <uses-permission android:name="android.permission.VIBRATE" />
 
     <uses-feature
         android:name="android.hardware.wifi"
@@ -27,21 +31,32 @@
         android:required="true" />
 
     <application
-        android:requestLegacyExternalStorage="true"
         android:allowBackup="true"
+        android:appCategory="game"
         android:dataExtractionRules="@xml/data_extraction_rules"
         android:fullBackupContent="@xml/backup_rules"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
+        android:hasFragileUserData="true"
+        android:requestLegacyExternalStorage="true"
         android:theme="@style/Theme.GeodeLauncher"
         tools:targetApi="31">
         <activity
-            android:name=".ApplicationLogsActivity"
+            android:name=".AltMainActivity"
+            android:exported="false"
+            android:theme="@style/Theme.GeodeLauncher" />
+        <activity
+            android:name=".preferences.DeveloperSettingsActivity"
+            android:exported="false"
+            android:label="@string/title_activity_developer_settings"
+            android:theme="@style/Theme.GeodeLauncher" />
+        <activity
+            android:name=".preferences.ApplicationLogsActivity"
             android:exported="false"
             android:label="@string/title_activity_application_logs"
             android:theme="@style/Theme.GeodeLauncher" />
         <activity
-            android:name=".SettingsActivity"
+            android:name=".preferences.SettingsActivity"
             android:exported="false"
             android:label="@string/title_activity_settings"
             android:theme="@style/Theme.GeodeLauncher">
@@ -55,6 +70,7 @@
             android:hardwareAccelerated="true"
             android:screenOrientation="landscape"
             android:theme="@style/Theme.NoActionBar.Fullscreen"
+            android:configChanges="orientation|screenSize|smallestScreenSize"
             android:windowSoftInputMode="stateAlwaysHidden">
             <meta-data
                 android:name="android.app.lib_name"
@@ -73,7 +89,7 @@
 
         <provider
             android:name=".UserDirectoryProvider"
-            android:authorities="com.geode.launcher.user"
+            android:authorities="com.geode.launcherXps.user"
             android:exported="true"
             android:grantUriPermissions="true"
             android:permission="android.permission.MANAGE_DOCUMENTS">
@@ -83,13 +99,17 @@
         </provider>
         <provider
             android:name="androidx.core.content.FileProvider"
-            android:authorities="com.geode.launcher.fileprovider"
+            android:authorities="com.geode.launcherXps.fileprovider"
             android:exported="false"
             android:grantUriPermissions="true">
             <meta-data
                 android:name="android.support.FILE_PROVIDER_PATHS"
                 android:resource="@xml/provider_paths" />
         </provider>
+
+        <meta-data
+            android:name="android.game_mode_config"
+            android:resource="@xml/game_mode_config" />
     </application>
 
 </manifest>

app/src/main/cpp/CMakeLists.txt

@@ -13,7 +13,7 @@ option(USE_TULIPHOOK "enables choice of hooking library" OFF)
 if (USE_TULIPHOOK)
     FetchContent_Declare(TulipHook
         GIT_REPOSITORY https://github.com/geode-sdk/TulipHook.git
-        GIT_TAG 70122be72da7787dc42813ba0a992f3612e7871e
+        GIT_TAG 0021301fcea265416fa8eb5372694931c1d410cb
     )
 
     set(TULIP_LINK_SOURCE ON CACHE INTERNAL "")

app/src/main/cpp/launcher-fix.cpp

@@ -1,7 +1,11 @@
 #include <dlfcn.h>
 #include <jni.h>
+#include <fstream>
 #include <string>
+#include <vector>
+#include <cstdint>
 #include <android/log.h>
+#include <link.h>
 
 #ifndef DISABLE_LAUNCHER_FIX
 
@@ -15,8 +19,9 @@
 
 class DataPaths {
 public:
-    std::string original_data_path;
-    std::string data_path;
+    std::string original_data_path{};
+    std::string data_path{};
+    std::string load_symbols_from{};
 
     static DataPaths& get_instance() {
         static auto paths_instance = DataPaths();
@@ -24,7 +29,7 @@ public:
     }
 
 private:
-    DataPaths() : original_data_path(), data_path() {}
+    DataPaths() {}
 };
 
 extern "C"
@@ -41,6 +46,20 @@ JNIEXPORT void JNICALL Java_com_geode_launcher_LauncherFix_setDataPath(
     env->ReleaseStringUTFChars(data_path, data_path_str);
 }
 
+extern "C"
+JNIEXPORT void JNICALL Java_com_geode_launcher_LauncherFix_enableCustomSymbolList(
+    JNIEnv* env,
+    jobject,
+    jstring symbol_path
+) {
+    auto is_copy = jboolean();
+    auto symbol_path_str = env->GetStringUTFChars(symbol_path, &is_copy);
+
+    DataPaths::get_instance().load_symbols_from = std::string(symbol_path_str);
+
+    env->ReleaseStringUTFChars(symbol_path, symbol_path_str);
+}
+
 extern "C"
 JNIEXPORT void JNICALL Java_com_geode_launcher_LauncherFix_setOriginalDataPath(
         JNIEnv *env,
@@ -55,9 +74,200 @@ JNIEXPORT void JNICALL Java_com_geode_launcher_LauncherFix_setOriginalDataPath(
     env->ReleaseStringUTFChars(data_path, data_path_str);
 }
 
-std::string redirect_path(const char* pathname) {
-    auto data_path = DataPaths::get_instance().data_path;
-    auto original_data_path = DataPaths::get_instance().original_data_path;
+// i copied this function from the android linker
+std::uint32_t elfhash(const char *_name) {
+    const unsigned char *name = reinterpret_cast<const unsigned char*>(_name);
+    std::uint32_t h = 0, g;
+
+    while (*name) {
+        h = (h << 4) + *name++;
+        g = h & 0xf0000000;
+        h ^= g;
+        h ^= g >> 24;
+    }
+
+    return h;
+}
+
+std::array<std::uint8_t, 3> SYMBOL_PATCH_VALUE{":3"};
+
+bool patch_symbol(std::uint32_t* hash_table, char* str_table, ElfW(Sym)* sym_table, const char* orig_name) {
+    auto hash = elfhash(orig_name);
+
+    auto nbucket = hash_table[0];
+    auto nchain = hash_table[1];
+    auto bucket = &hash_table[2];
+    auto chain = &bucket[nbucket];
+
+    for (auto i = bucket[hash % nbucket]; i != 0; i = chain[i]) {
+        auto sym = sym_table + i;
+        auto sym_name = str_table + sym->st_name;
+
+        if (strcmp(sym_name, orig_name) == 0) {
+            // there's probably no point to checking this, honestly
+            if (ELF_ST_BIND(sym->st_info) == STB_GLOBAL && ELF_ST_TYPE(sym->st_info) == STT_FUNC) {
+                // we found it! now go rename the symbol
+
+#ifdef USE_TULIPHOOK
+                auto res = tulip::hook::writeMemory(sym_name, new_symbol.data(), new_symbol.size());
+                if (!res) {
+                        __android_log_print(ANDROID_LOG_WARN, "GeodeLauncher-fix", "failed to patch symbol: %s", res.unwrapErr().c_str());
+                        return false;
+                }
+#else
+                DobbyCodePatch(reinterpret_cast<void*>(sym_name), SYMBOL_PATCH_VALUE.data(), SYMBOL_PATCH_VALUE.size());
+#endif
+
+                return true;
+            }
+        }
+    }
+
+    __android_log_print(ANDROID_LOG_WARN, "GeodeLauncher-fix", "could not find symbol %s to patch (hash: %u)", orig_name, hash);
+    return false;
+}
+
+std::vector<std::string> get_symbols_listing() {
+    auto symbol_path = DataPaths::get_instance().load_symbols_from;
+    if (symbol_path.empty()) {
+        // this is every function that i thought would be relevant
+        return {
+                "__gxx_personality_v0",
+                "__cxa_throw",
+                "__cxa_rethrow",
+                "__cxa_allocate_exception",
+                "__cxa_end_catch",
+                "__cxa_begin_catch",
+                "__cxa_guard_abort",
+                "__cxa_guard_acquire",
+                "__cxa_guard_release",
+                "__cxa_free_exception"
+
+                // android 10's libc doesn't have these symbols
+                // and the ndk is forbidden from exporting them!! so keep it for old mods...
+                // "_Unwind_RaiseException",
+                // "_Unwind_Resume"
+        };
+    }
+
+    std::ifstream symbol_file{symbol_path};
+    if (!symbol_file) {
+        __android_log_print(ANDROID_LOG_WARN, "GeodeLauncher-fix", "failed to read symbol file at %s", symbol_path.c_str());
+        return {};
+    }
+
+    std::vector<std::string> symbols_list{};
+    std::string current_line{};
+    while (std::getline(symbol_file, current_line)) {
+        if (!current_line.empty()) {
+            symbols_list.push_back(current_line);
+        }
+    }
+
+    return symbols_list;
+}
+
+int on_dl_iterate(dl_phdr_info* info, size_t size, void* data) {
+    // this is probably going to be gd
+    if (info->dlpi_name != nullptr && strstr(info->dlpi_name, "libcocos2dcpp.so") != nullptr) {
+        // step 1: get the dynamic table
+        std::uintptr_t dyn_addr = 0u;
+
+        for (auto i = 0u; i < info->dlpi_phnum; i++) {
+            auto phdr = info->dlpi_phdr + i;
+
+            if (phdr->p_type == PT_DYNAMIC) {
+                dyn_addr = info->dlpi_addr + phdr->p_vaddr;
+                break;
+            }
+        }
+
+        if (dyn_addr == 0u) {
+            __android_log_print(ANDROID_LOG_WARN, "GeodeLauncher-fix", "failed to find libcocos dynamic section");
+            return 0;
+        }
+
+        // step 2: get the symbol table
+        auto dyn_entry = reinterpret_cast<ElfW(Dyn)*>(dyn_addr);
+        auto dyn_end_reached = false;
+
+        std::uintptr_t sym_table_addr = 0u;
+        std::uintptr_t str_table_addr = 0u;
+        std::uintptr_t hash_table_addr = 0u;
+        std::uintptr_t soname_idx = 0u;
+
+        while (!dyn_end_reached) {
+            auto tag = dyn_entry->d_tag;
+
+            switch (dyn_entry->d_tag) {
+                case DT_SYMTAB:
+                    sym_table_addr = info->dlpi_addr + dyn_entry->d_un.d_val;
+                    break;
+                case DT_STRTAB:
+                    str_table_addr = info->dlpi_addr + dyn_entry->d_un.d_val;
+                    break;
+                case DT_HASH:
+                    hash_table_addr = info->dlpi_addr + dyn_entry->d_un.d_val;
+                    break;
+                case DT_SONAME:
+                    soname_idx = dyn_entry->d_un.d_val;
+                    break;
+                case DT_NULL:
+                    dyn_end_reached = true;
+                    break;
+            }
+
+            dyn_entry++;
+        }
+
+        if (hash_table_addr == 0u || str_table_addr == 0u || sym_table_addr == 0u) {
+            __android_log_print(ANDROID_LOG_ERROR, "GeodeLauncher-fix", "failed to parse dynamic section (at least one table is null)");
+            return -1;
+        }
+
+        // patch symbol names
+        auto hash_table = reinterpret_cast<std::uint32_t*>(hash_table_addr);
+        auto str_table = reinterpret_cast<char*>(str_table_addr);
+        auto sym_table = reinterpret_cast<ElfW(Sym)*>(sym_table_addr);
+
+        auto so_name = str_table + soname_idx;
+        if (strcmp(so_name, "libcocos2dcpp.so") != 0) {
+            __android_log_print(ANDROID_LOG_WARN, "GeodeLauncher-fix", "DT_SONAME gives us %s! that's not good", so_name);
+        }
+
+        auto has_error = false;
+        auto symbols_listing = get_symbols_listing();
+        for (const auto& symbol : symbols_listing) {
+            if (!patch_symbol(hash_table, str_table, sym_table, symbol.c_str())) {
+                has_error = true;
+            }
+        }
+
+        if (has_error) {
+            __android_log_print(
+                    ANDROID_LOG_INFO,
+                    "GeodeLauncher-fix",
+                    "symbol patch diagnostics\nlibrary path: %s\naddrs: base=%p sym=%p str=%p hash=%p",
+                    info->dlpi_name, reinterpret_cast<void*>(info->dlpi_addr), sym_table, str_table, hash_table
+                );
+        }
+
+        return 1;
+    }
+
+    return 0;
+
+}
+
+// this should be called after gd is loaded but before geode
+extern "C"
+JNIEXPORT int JNICALL Java_com_geode_launcher_LauncherFix_performExceptionsRenaming(JNIEnv*, jobject) {
+    return dl_iterate_phdr(on_dl_iterate, nullptr);
+}
+
+std::optional<std::string> redirect_path(const char* pathname) {
+    auto& data_path = DataPaths::get_instance().data_path;
+    auto& original_data_path = DataPaths::get_instance().original_data_path;
 
     if (!data_path.empty() && !original_data_path.empty()) {
         // call this a c string optimization
@@ -68,22 +278,26 @@ std::string redirect_path(const char* pathname) {
         }
     }
 
-    return pathname;
+    return std::nullopt;
 }
 
 FILE* (*fopen_original)(const char *pathname, const char *mode);
 FILE* fopen_hook(const char* pathname, const char* mode) {
     auto path_str = redirect_path(pathname);
+    auto redirect = path_str.has_value() ? path_str->c_str() : pathname;
 
-    return fopen_original(path_str.c_str(), mode);
+    return fopen_original(redirect, mode);
 }
 
 int (*rename_original)(const char* old_path, const char* new_path);
 int rename_hook(const char* old_path, const char* new_path) {
     auto old_path_str = redirect_path(old_path);
-    auto new_path_str = redirect_path(new_path);
+    auto old_redirect = old_path_str ? old_path_str->c_str() : old_path;
 
-    return rename_original(old_path_str.c_str(), new_path_str.c_str());
+    auto new_path_str = redirect_path(new_path);
+    auto new_redirect = new_path_str ? new_path_str->c_str() : new_path;
+
+    return rename_original(old_redirect, new_redirect);
 }
 
 bool hook_function(void* addr, auto* hook, auto** orig) {

app/src/main/java/com/customRobTop/BaseRobTopActivity.kt

@@ -2,7 +2,6 @@ package com.customRobTop
 
 import android.annotation.SuppressLint
 import android.app.Activity
-import android.app.KeyguardManager
 import android.content.*
 import android.net.ConnectivityManager
 import android.net.NetworkCapabilities
@@ -11,7 +10,6 @@ import android.os.Build
 import android.provider.Settings
 import android.util.Log
 import android.widget.Toast
-import com.customRobTop.JniToCpp.resumeSound
 import org.cocos2dx.lib.Cocos2dxGLSurfaceView.Companion.closeIMEKeyboard
 import org.cocos2dx.lib.Cocos2dxGLSurfaceView.Companion.openIMEKeyboard
 import java.lang.ref.WeakReference
@@ -259,29 +257,4 @@ object BaseRobTopActivity {
         level = DeprecationLevel.HIDDEN
     )
     fun logEvent(event: String) {}
-
-    class ReceiverScreen : BroadcastReceiver() {
-        override fun onReceive(context: Context, intent: Intent) {
-            when (intent.action) {
-                Intent.ACTION_SCREEN_ON -> {
-                    Log.d("TAG", "ACTION_SCREEN_ON")
-                    if (!(me.get()?.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager).isKeyguardLocked) {
-                        shouldResumeSound = true
-                    }
-                    if (!isPaused && shouldResumeSound) {
-                        resumeSound()
-                    }
-                }
-                Intent.ACTION_SCREEN_OFF -> {
-                    shouldResumeSound = false
-                }
-                Intent.ACTION_USER_PRESENT -> {
-                    shouldResumeSound = true
-                    if (!isPaused) {
-                        resumeSound()
-                    }
-                }
-            }
-        }
-    }
 }

app/src/main/java/com/geode/launcher/AltMainActivity.kt

@@ -0,0 +1,522 @@
+package com.geode.launcher
+
+import android.os.Bundle
+import android.text.format.Formatter
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Info
+import androidx.compose.material.icons.filled.PlayArrow
+import androidx.compose.material.icons.filled.Refresh
+import androidx.compose.material.icons.filled.Settings
+import androidx.compose.material.icons.filled.Warning
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.FilledTonalButton
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.LinearProgressIndicator
+import androidx.compose.material3.LocalTextStyle
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.viewmodel.compose.viewModel
+import com.geode.launcher.main.*
+import com.geode.launcher.ui.theme.GeodeLauncherTheme
+import com.geode.launcher.ui.theme.LocalTheme
+import com.geode.launcher.ui.theme.Theme
+import com.geode.launcher.utils.Constants
+import com.geode.launcher.utils.GamePackageUtils
+import com.geode.launcher.utils.LaunchUtils
+import com.geode.launcher.utils.PreferenceUtils
+import kotlinx.coroutines.launch
+
+class AltMainActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        enableEdgeToEdge()
+        clearDownloadedApks(this)
+
+        val gdInstalled = GamePackageUtils.isGameInstalled(packageManager)
+        val geodeInstalled = LaunchUtils.isGeodeInstalled(this)
+
+        val returnMessage = intent.extras?.getString(LaunchUtils.LAUNCHER_KEY_RETURN_MESSAGE)
+        val returnExtendedMessage = intent.extras?.getString(LaunchUtils.LAUNCHER_KEY_RETURN_EXTENDED_MESSAGE)
+
+        @Suppress("DEPRECATION") // the new api is android 13 only (why)
+        val returnError = intent.extras?.getSerializable(LaunchUtils.LAUNCHER_KEY_RETURN_ERROR)
+                as? LaunchUtils.LauncherError
+
+        val loadFailureInfo = if (returnError != null && returnMessage != null) {
+            LoadFailureInfo(returnError, returnMessage, returnExtendedMessage)
+        } else if (LaunchUtils.lastSessionCrashed(this)) {
+            LoadFailureInfo(LaunchUtils.LauncherError.CRASHED)
+        } else { null }
+
+
+        setContent {
+            val themeOption by PreferenceUtils.useIntPreference(PreferenceUtils.Key.THEME)
+            val theme = Theme.fromInt(themeOption)
+
+            val backgroundOption by PreferenceUtils.useBooleanPreference(PreferenceUtils.Key.BLACK_BACKGROUND)
+
+            val launchViewModel = viewModel<LaunchViewModel>(factory = LaunchViewModel.Factory)
+
+            if (loadFailureInfo != null) {
+                launchViewModel.loadFailure = loadFailureInfo
+            }
+
+            CompositionLocalProvider(LocalTheme provides theme) {
+                GeodeLauncherTheme(theme = theme, blackBackground = backgroundOption) {
+                    Surface(
+                        modifier = Modifier.fillMaxSize()
+                    ) {
+                        AltMainScreen(launchViewModel)
+                    }
+                }
+            }
+        }
+
+        if (gdInstalled && geodeInstalled) {
+            intent.getBooleanExtra("restarted", false).let {
+                if (it) {
+                    onLaunch(this)
+                }
+            }
+        }
+    }
+}
+
+data class LaunchStatusInfo(
+    val title: String?,
+    val details: String? = null,
+    val progress: (() -> Float)? = null
+)
+
+@Composable
+fun LaunchCancelledIcon(cancelReason: LaunchViewModel.LaunchCancelReason, modifier: Modifier = Modifier) {
+    when (cancelReason) {
+        LaunchViewModel.LaunchCancelReason.GAME_OUTDATED,
+        LaunchViewModel.LaunchCancelReason.GAME_MISSING -> Icon(painterResource(R.drawable.icon_error), contentDescription = null, modifier)
+        LaunchViewModel.LaunchCancelReason.LAST_LAUNCH_CRASHED,
+        LaunchViewModel.LaunchCancelReason.GEODE_NOT_FOUND -> Icon(Icons.Default.Warning, contentDescription = null, modifier)
+        else -> Icon(Icons.Default.Info, contentDescription = null, modifier)
+    }
+}
+
+@Composable
+fun mapCancelReasonToInfo(cancelReason: LaunchViewModel.LaunchCancelReason): LaunchStatusInfo {
+    return when (cancelReason) {
+        LaunchViewModel.LaunchCancelReason.LAST_LAUNCH_CRASHED -> LaunchStatusInfo(
+            title = stringResource(R.string.launcher_cancelled_crash)
+        )
+        LaunchViewModel.LaunchCancelReason.GEODE_NOT_FOUND -> LaunchStatusInfo(
+            title = stringResource(R.string.geode_download_title)
+        )
+        LaunchViewModel.LaunchCancelReason.GAME_MISSING -> LaunchStatusInfo(
+            title = stringResource(R.string.launcher_cancelled_error),
+            details = stringResource(R.string.game_not_found)
+        )
+        LaunchViewModel.LaunchCancelReason.GAME_OUTDATED -> LaunchStatusInfo(
+            title = stringResource(R.string.launcher_cancelled_error),
+            details = stringResource(R.string.launcher_cancelled_outdated)
+        )
+        LaunchViewModel.LaunchCancelReason.AUTOMATIC,
+        LaunchViewModel.LaunchCancelReason.MANUAL-> LaunchStatusInfo(
+            title = null
+        )
+        else -> LaunchStatusInfo(
+            title = stringResource(R.string.launcher_cancelled_manual)
+        )
+    }
+}
+
+@Composable
+fun mapLaunchStatusToInfo(state: LaunchViewModel.LaunchUIState, inSafeMode: Boolean = false): LaunchStatusInfo {
+    return when (state) {
+        is LaunchViewModel.LaunchUIState.Initial,
+        is LaunchViewModel.LaunchUIState.Working,
+        is LaunchViewModel.LaunchUIState.Ready -> LaunchStatusInfo(
+            title = stringResource(R.string.launcher_starting_game),
+            details = if (inSafeMode) stringResource(R.string.launcher_in_safe_mode) else null
+        )
+        is LaunchViewModel.LaunchUIState.UpdateCheck -> LaunchStatusInfo(
+            title = stringResource(R.string.release_fetch_in_progress)
+        )
+        is LaunchViewModel.LaunchUIState.Updating -> {
+            val context = LocalContext.current
+
+            val downloaded = remember(state.downloaded) {
+                Formatter.formatShortFileSize(context, state.downloaded)
+            }
+
+            val outOf = remember(state.outOf) {
+                state.outOf?.run {
+                    Formatter.formatShortFileSize(context, this)
+                }
+            }
+
+            LaunchStatusInfo(
+                title = stringResource(R.string.launcher_downloading_update),
+                details = stringResource(R.string.launcher_downloading_update_details, downloaded, outOf ?: "…"),
+                progress = {
+                    val progress = state.downloaded / state.outOf!!.toDouble()
+                    progress.toFloat()
+                }.takeIf { state.outOf != null }
+            )
+        }
+        is LaunchViewModel.LaunchUIState.Cancelled -> {
+            return mapCancelReasonToInfo(state.reason)
+        }
+    }
+}
+
+@Composable
+fun LaunchCancelledBody(statusInfo: LaunchStatusInfo, icon: @Composable () -> Unit, inProgress: Boolean, modifier: Modifier = Modifier) {
+    if (statusInfo.title == null && statusInfo.details == null && !inProgress) {
+        return
+    }
+
+    Column(
+        verticalArrangement = Arrangement.spacedBy(8.dp),
+        horizontalAlignment = Alignment.CenterHorizontally,
+        modifier = modifier.width(300.dp)
+    ) {
+        if (statusInfo.title != null) {
+            Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.Center) {
+                CompositionLocalProvider(LocalTextStyle provides MaterialTheme.typography.bodyLarge) {
+                    icon()
+                    Spacer(Modifier.size(8.dp))
+                    Text(statusInfo.title)
+                }
+            }
+        }
+
+        if (inProgress) {
+            LinearProgressIndicator(modifier = Modifier.fillMaxWidth())
+        }
+
+        if (statusInfo.details != null) {
+            Text(
+                statusInfo.details,
+                style = MaterialTheme.typography.bodyMedium,
+                textAlign = TextAlign.Center
+            )
+        }
+    }
+
+}
+
+@Composable
+fun LaunchProgressBody(statusInfo: LaunchStatusInfo, modifier: Modifier = Modifier) {
+    Column(
+        verticalArrangement = Arrangement.spacedBy(12.dp),
+        horizontalAlignment = Alignment.Start,
+        modifier = modifier.width(300.dp)
+    ) {
+        if (statusInfo.title != null) {
+            Text(statusInfo.title, style = MaterialTheme.typography.bodyLarge)
+        }
+
+        if (statusInfo.progress != null) {
+            LinearProgressIndicator(
+                statusInfo.progress,
+                modifier = Modifier.fillMaxWidth()
+            )
+        } else {
+            LinearProgressIndicator(modifier = Modifier.fillMaxWidth())
+        }
+
+        if (statusInfo.details != null) {
+            Text(statusInfo.details, style = MaterialTheme.typography.bodyMedium)
+        }
+    }
+}
+
+@Composable
+fun RetryButtonContents(reason: LaunchViewModel.LaunchCancelReason) {
+    when (reason) {
+        LaunchViewModel.LaunchCancelReason.LAST_LAUNCH_CRASHED -> {
+            Icon(
+                painterResource(R.drawable.icon_resume),
+                contentDescription = null
+            )
+            Spacer(Modifier.size(ButtonDefaults.IconSpacing))
+            Text(stringResource(R.string.launcher_cancelled_resume))
+        }
+        LaunchViewModel.LaunchCancelReason.MANUAL,
+        LaunchViewModel.LaunchCancelReason.AUTOMATIC -> {
+            Icon(
+                Icons.Filled.PlayArrow,
+                contentDescription = null
+            )
+            Spacer(Modifier.size(ButtonDefaults.IconSpacing))
+            Text(stringResource(R.string.launcher_launch))
+        }
+        LaunchViewModel.LaunchCancelReason.GEODE_NOT_FOUND -> {
+            Icon(
+                Icons.Filled.Refresh,
+                contentDescription = null
+            )
+            Spacer(Modifier.size(ButtonDefaults.IconSpacing))
+            Text(stringResource(R.string.launcher_cancelled_retry))
+        }
+        // these shouldn't be allowing retries anyways
+        LaunchViewModel.LaunchCancelReason.GAME_MISSING,
+        LaunchViewModel.LaunchCancelReason.GAME_OUTDATED -> {}
+    }
+}
+
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+fun LaunchProgressCard(
+    uiState: LaunchViewModel.LaunchUIState,
+    crashInfo: LoadFailureInfo?,
+    onCancel: () -> Unit, 
+    onResume: (safeMode: Boolean) -> Unit,
+    onMore: () -> Unit,
+    extraOptions: @Composable () -> Unit,
+    safeModeEnabled: Boolean,
+    modifier: Modifier = Modifier
+) {
+    var showSafeModeDialog by remember { mutableStateOf(false) }
+    val status = mapLaunchStatusToInfo(uiState, safeModeEnabled)
+
+    Box(modifier = modifier) {
+        Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
+            if (uiState is LaunchViewModel.LaunchUIState.Cancelled) {
+                LaunchCancelledBody(
+                    statusInfo = status,
+                    icon = { LaunchCancelledIcon(uiState.reason, Modifier.size(32.dp)) },
+                    inProgress = uiState.inProgress
+                )
+
+                if (uiState.reason.isGameInstallIssue()) {
+                    val context = LocalContext.current
+                    val showDownload = remember { GamePackageUtils.showDownloadBadge(context.packageManager) }
+
+                    if (showDownload) {
+                        GooglePlayBadge(modifier = Modifier.align(Alignment.CenterHorizontally))
+                    }
+                }
+
+                if (uiState.reason.allowsRetry()) {
+                    FlowRow(
+                        horizontalArrangement = Arrangement.spacedBy(8.dp, alignment = Alignment.CenterHorizontally),
+                        modifier = Modifier.align(Alignment.CenterHorizontally)
+                    ) {
+                        LongPressButton(onClick = { onResume(false) }, onLongPress = {
+                            showSafeModeDialog = true
+                        }) {
+                            RetryButtonContents(uiState.reason)
+                        }
+
+                        if (crashInfo != null) {
+                            FilledTonalButton(onClick = onMore) {
+                                Icon(
+                                    painterResource(R.drawable.icon_question_mark),
+                                    contentDescription = null
+                                )
+                                Spacer(Modifier.size(ButtonDefaults.IconSpacing))
+                                Text(stringResource(R.string.launcher_cancelled_help_alt))
+                            }
+                        }
+
+                        extraOptions()
+                    }
+                }
+            } else {
+                LaunchProgressBody(statusInfo = status, modifier = Modifier.padding(top = 16.dp))
+
+                Row(horizontalArrangement = Arrangement.spacedBy(8.dp), modifier = Modifier.width(300.dp)) {
+                    TextButton(onClick = onCancel) {
+                        Text(stringResource(R.string.release_fetch_button_cancel))
+                    }
+
+                    Spacer(Modifier.weight(1.0f))
+
+                    extraOptions()
+                }
+            }
+        }
+    }
+
+    if (showSafeModeDialog) {
+        SafeModeDialog(
+            onDismiss = {
+                showSafeModeDialog = false
+            },
+            onLaunch = {
+                onResume(true)
+                showSafeModeDialog = false
+            }
+        )
+    }
+}
+
+@Composable
+fun ExtraOptions(onSettings: () -> Unit) {
+    IconButton(
+        onClick = onSettings,
+    ) {
+        Icon(
+            Icons.Filled.Settings,
+            contentDescription = stringResource(R.string.launcher_settings_icon_alt)
+        )
+    }
+}
+
+@Composable
+fun GeodeLogo(modifier: Modifier = Modifier) {
+    Row(
+        horizontalArrangement = Arrangement.Center,
+        verticalAlignment = Alignment.CenterVertically,
+        modifier = modifier
+    ) {
+        Image(
+            painter = painterResource(id = R.drawable.geode_logo),
+            contentDescription = null,
+            modifier = Modifier.size(76.dp, 76.dp)
+        )
+        Text(
+            stringResource(R.string.launcher_title),
+            style = MaterialTheme.typography.displayMedium,
+            modifier = Modifier.padding(12.dp)
+        )
+    }
+}
+
+@Composable
+fun AltMainScreen(
+    launchViewModel: LaunchViewModel = viewModel(factory = LaunchViewModel.Factory)
+) {
+    val context = LocalContext.current
+
+    LaunchedEffect(Unit) {
+        launchViewModel.beginLaunchFlow()
+    }
+
+    val launchUIState by launchViewModel.uiState.collectAsState()
+    val coroutineScope = rememberCoroutineScope()
+    var launchInSafeMode by remember { mutableStateOf(false) }
+
+    var showErrorInfo by remember { mutableStateOf(false) }
+
+    Box(
+        modifier = Modifier
+            .fillMaxSize()
+            .safeDrawingPadding(),
+        contentAlignment = Alignment.Center
+    ) {
+        Column(
+            verticalArrangement = Arrangement.spacedBy(16.dp),
+            horizontalAlignment = Alignment.CenterHorizontally,
+            modifier = Modifier
+                .padding(8.dp)
+                .verticalScroll(rememberScrollState())
+        ) {
+            GeodeLogo()
+
+            Column(
+                verticalArrangement = Arrangement.spacedBy(8.dp),
+                horizontalAlignment = Alignment.CenterHorizontally,
+            ) {
+                LaunchProgressCard(
+                    launchUIState,
+                    crashInfo = launchViewModel.currentCrashInfo(),
+                    onCancel = {
+                        launchInSafeMode = false
+                        coroutineScope.launch {
+                            launchViewModel.cancelLaunch()
+                        }
+                    },
+                    onResume = { safeMode ->
+                        launchInSafeMode = safeMode
+
+                        launchViewModel.clearCrashInfo()
+                        coroutineScope.launch {
+                            launchViewModel.beginLaunchFlow(true)
+                        }
+                    },
+                    onMore = {
+                        showErrorInfo = true
+                    },
+                    extraOptions = {
+                        ExtraOptions(
+                            onSettings = {
+                                coroutineScope.launch {
+                                    launchViewModel.cancelLaunch(true)
+                                }
+
+                                onSettings(context)
+                            }
+                        )
+                    },
+                    safeModeEnabled = launchInSafeMode
+                )
+
+                // only show launcher update in a case where a user won't see it ingame
+                if (launchUIState is LaunchViewModel.LaunchUIState.Cancelled) {
+                    val gameVersion = remember { GamePackageUtils.getGameVersionCodeOrNull(context.packageManager) }
+
+                    if (gameVersion != null && gameVersion < Constants.SUPPORTED_VERSION_CODE_MIN_WARNING) {
+                        UnsupportedVersionWarning()
+                    }
+
+                    val nextLauncherUpdate by launchViewModel.nextLauncherUpdate.collectAsState()
+                    if (nextLauncherUpdate != null) {
+                        LauncherUpdateIndicator()
+                    }
+                }
+            }
+        }
+    }
+
+    if (launchUIState is LaunchViewModel.LaunchUIState.Ready) {
+        UpdateWarning(launchInSafeMode) {
+            launchInSafeMode = false
+            coroutineScope.launch {
+                launchViewModel.cancelLaunch()
+            }
+        }
+    }
+
+    val loadFailure = launchViewModel.currentCrashInfo()
+    if (showErrorInfo && loadFailure != null) {
+        ErrorInfoSheet(loadFailure, onDismiss = { showErrorInfo = false })
+    }
+}

app/src/main/java/com/geode/launcher/GeometryDashActivity.kt

@@ -1,29 +1,33 @@
 package com.geode.launcher
 
 import android.annotation.SuppressLint
-import android.content.BroadcastReceiver
 import android.content.Intent
-import android.content.IntentFilter
 import android.content.pm.ActivityInfo
 import android.content.pm.ApplicationInfo
 import android.content.pm.PackageInfo
+import android.opengl.GLSurfaceView
 import android.os.Build
 import android.os.Bundle
 import android.os.Environment
+import android.text.InputType
 import android.util.Log
 import android.view.ViewGroup
 import android.view.WindowManager
 import android.widget.FrameLayout
 import androidx.appcompat.app.AlertDialog
 import androidx.appcompat.app.AppCompatActivity
+import androidx.compose.ui.platform.ComposeView
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.WindowInsetsControllerCompat
 import com.customRobTop.BaseRobTopActivity
 import com.customRobTop.JniToCpp
+import com.geode.launcher.main.LaunchNotification
+import com.geode.launcher.main.determineDisplayedCards
 import com.geode.launcher.utils.Constants
 import com.geode.launcher.utils.ConstrainedFrameLayout
 import com.geode.launcher.utils.DownloadUtils
+import com.geode.launcher.utils.GamePackageUtils
 import com.geode.launcher.utils.GeodeUtils
 import com.geode.launcher.utils.LaunchUtils
 import com.geode.launcher.utils.PreferenceUtils
@@ -35,6 +39,10 @@ import org.fmod.FMOD
 import java.io.File
 import java.io.FileInputStream
 import java.io.FileOutputStream
+import java.io.IOException
+import javax.microedition.khronos.egl.EGL10
+import javax.microedition.khronos.egl.EGLConfig
+import javax.microedition.khronos.egl.EGLDisplay
 
 enum class DisplayMode {
     DEFAULT, LIMITED, FULLSCREEN;
@@ -48,40 +56,54 @@ enum class DisplayMode {
     }
 }
 
+fun ratioForPreference(value: String) = when (value) {
+    "4_3" -> 4/3.0f
+    "1_1" -> 1.0f
+    "16_10" -> 16/10.0f
+    else -> 1.77f
+}
+
 class GeometryDashActivity : AppCompatActivity(), Cocos2dxHelper.Cocos2dxHelperListener, GeodeUtils.CapabilityListener {
     private var mGLSurfaceView: Cocos2dxGLSurfaceView? = null
-    private val sTag = GeometryDashActivity::class.simpleName
     private var mIsRunning = false
     private var mIsOnPause = false
     private var mHasWindowFocus = false
-    private var mReceiver: BroadcastReceiver? = null
 
     private var displayMode = DisplayMode.DEFAULT
+    private var mForceRefreshRate = false
+    private var mLimitedRefreshRate: Int? = null
+    private var mAspectRatio = 0.0f
+    private var mScreenZoom = 1.0f
+    private var mScreenZoomFit = false
 
     override fun onCreate(savedInstanceState: Bundle?) {
         setupUIState()
+        FMOD.init(this)
 
         super.onCreate(savedInstanceState)
 
         // return back to main if Geometry Dash isn't found
-        if (!LaunchUtils.isGeometryDashInstalled(packageManager)) {
+        if (!GamePackageUtils.isGameInstalled(packageManager)) {
             returnToMain()
             return
         }
 
         try {
+            createVersionFile()
             tryLoadGame()
         } catch (e: UnsatisfiedLinkError) {
             Log.e("GeodeLauncher", "Library linkage failure", e)
 
             // generates helpful information for use in debugging library load failures
             val gdPackageInfo = packageManager.getPackageInfo(Constants.PACKAGE_NAME, 0)
-            val abiMismatch = LaunchUtils.detectAbiMismatch(this, gdPackageInfo, e)
+            val abiMismatch = GamePackageUtils.detectAbiMismatch(this, gdPackageInfo, e)
 
             val is64bit = LaunchUtils.is64bit
             val errorMessage = when {
                 abiMismatch && is64bit -> LaunchUtils.LauncherError.LINKER_NEEDS_32BIT
                 abiMismatch -> LaunchUtils.LauncherError.LINKER_NEEDS_64BIT
+                e.message?.contains("__gxx_personality_v0") == true ->
+                    LaunchUtils.LauncherError.LINKER_FAILED_STL
                 else -> LaunchUtils.LauncherError.LINKER_FAILED
             }
 
@@ -101,6 +123,13 @@ class GeometryDashActivity : AppCompatActivity(), Cocos2dxHelper.Cocos2dxHelperL
         }
     }
 
+    private fun createVersionFile() {
+        val versionPath = File(filesDir, "game_version.txt")
+        val gameVersion = GamePackageUtils.getGameVersionCode(packageManager)
+
+        versionPath.writeText("$gameVersion")
+    }
+
     private fun returnToMain(
         error: LaunchUtils.LauncherError? = null,
         returnMessage: String? = null,
@@ -132,10 +161,22 @@ class GeometryDashActivity : AppCompatActivity(), Cocos2dxHelper.Cocos2dxHelperL
         tryLoadLibrary(gdPackageInfo, Constants.FMOD_LIB_NAME)
         tryLoadLibrary(gdPackageInfo, Constants.COCOS_LIB_NAME)
 
-        if (getLoadTesting()) {
-            loadTestingLibraries()
+        if (GamePackageUtils.getGameVersionCode(packageManager) >= 39L) {
+            /*
+            val customSymbols = PreferenceUtils.get(this).getBoolean(PreferenceUtils.Key.CUSTOM_SYMBOL_LIST)
+            if (customSymbols) {
+                val symbolFile = File(LaunchUtils.getBaseDirectory(this), "exception_symbols.txt")
+                LauncherFix.enableCustomSymbolList(symbolFile.path)
+            }
+            */
+
+            // this fix requires geode v3, which is 2.206+
+            // there is a short period in which 2.206 users will still have geode v2, but whatever. ig
+            LauncherFix.performExceptionsRenaming()
         }
 
+        loadInternalMods()
+
         setContentView(createView())
 
         setupPostLibraryLoad(gdPackageInfo)
@@ -152,19 +193,16 @@ class GeometryDashActivity : AppCompatActivity(), Cocos2dxHelper.Cocos2dxHelperL
     private fun handleGeodeException(e: Throwable) {
         e.printStackTrace()
 
-        val ignoreFailure = PreferenceUtils.get(this)
-            .getBoolean(PreferenceUtils.Key.IGNORE_LOAD_FAILURE)
-
-        if (ignoreFailure) {
-            Log.w("GeodeLauncher", "could not load Geode object!")
-        } else {
+        // ignore load failures if the game is newer than what's supported
+        // so people in the future can use their save data
+        if (GamePackageUtils.getGameVersionCode(packageManager) <= Constants.SUPPORTED_VERSION_CODE) {
             throw e
         }
     }
 
     private fun setupRedirection(packageInfo: PackageInfo) {
         try {
-            LaunchUtils.addAssetsFromPackage(assets, packageInfo)
+            GamePackageUtils.addAssetsFromPackage(assets, packageInfo)
         } catch (e: NoSuchMethodException) {
             Log.e("GeodeLauncher", "Failed to add asset redirection", e)
         }
@@ -174,6 +212,9 @@ class GeometryDashActivity : AppCompatActivity(), Cocos2dxHelper.Cocos2dxHelperL
             val saveDir = LaunchUtils.getSaveDirectory(this)
             saveDir.mkdir()
 
+            // make sure it's loaded, just in case
+            System.loadLibrary("c++_shared")
+
             LauncherFix.loadLibrary()
             LauncherFix.setOriginalDataPath(Constants.GJ_DATA_DIR)
             LauncherFix.setDataPath(saveDir.path)
@@ -183,22 +224,19 @@ class GeometryDashActivity : AppCompatActivity(), Cocos2dxHelper.Cocos2dxHelperL
     }
 
     private fun setupPostLibraryLoad(packageInfo: PackageInfo) {
-        FMOD.init(this)
-
         // call native functions after native libraries init
         JniToCpp.setupHSSAssets(
-            packageInfo.applicationInfo.sourceDir,
+            packageInfo.applicationInfo!!.sourceDir,
             Environment.getExternalStorageDirectory().absolutePath
         )
-        Cocos2dxHelper.nativeSetApkPath(packageInfo.applicationInfo.sourceDir)
+        Cocos2dxHelper.nativeSetApkPath(packageInfo.applicationInfo!!.sourceDir)
 
         BaseRobTopActivity.setCurrentActivity(this)
-        registerReceiver()
     }
 
     @SuppressLint("UnsafeDynamicallyLoadedCode")
     private fun tryLoadLibrary(packageInfo: PackageInfo, libraryName: String) {
-        val nativeDir = getNativeLibraryDirectory(packageInfo.applicationInfo)
+        val nativeDir = getNativeLibraryDirectory(packageInfo.applicationInfo!!)
         val libraryPath = if (nativeDir.endsWith('/')) "${nativeDir}lib$libraryName.so" else "$nativeDir/lib$libraryName.so"
 
         try {
@@ -224,7 +262,7 @@ class GeometryDashActivity : AppCompatActivity(), Cocos2dxHelper.Cocos2dxHelperL
         }
 
         val library = File(libraryPath)
-        val libraryCopy = File(cacheDir, libraryName)
+        val libraryCopy = File(cacheDir, "lib$libraryName.so")
 
         libraryCopy.outputStream().use { libraryOutput ->
             library.inputStream().use { inputStream ->
@@ -345,8 +383,15 @@ class GeometryDashActivity : AppCompatActivity(), Cocos2dxHelper.Cocos2dxHelperL
         frameLayout.layoutParams = frameLayoutParams
 
         if (displayMode == DisplayMode.LIMITED) {
-            // despite not being perfectly 16:9, this is what Android calls "16:9"
-            frameLayout.aspectRatio = 1.86f
+            frameLayout.aspectRatio = mAspectRatio
+        }
+
+        if (mScreenZoomFit && mScreenZoom != 1.0f) {
+            frameLayout.fitZoom = true
+        }
+
+        if (mScreenZoom != 1.0f) {
+            frameLayout.zoom = mScreenZoom
         }
 
         val editTextLayoutParams = ViewGroup.LayoutParams(
@@ -362,16 +407,35 @@ class GeometryDashActivity : AppCompatActivity(), Cocos2dxHelper.Cocos2dxHelperL
         this.mGLSurfaceView = glSurfaceView
         frameLayout.addView(this.mGLSurfaceView)
 
-        glSurfaceView.setEGLConfigChooser(5, 6, 5, 0, 16, 8)
+        val showNotification = PreferenceUtils.get(this).getBoolean(PreferenceUtils.Key.ENABLE_REDESIGN)
+        if (showNotification) {
+            val hasCards = determineDisplayedCards(this)
+            if (hasCards.isNotEmpty()) {
+                val notificationView = ComposeView(this)
+                frameLayout.addView(notificationView)
 
-        if (isAndroidEmulator()) {
-            glSurfaceView.setEGLConfigChooser(8, 8, 8, 8, 16, 0)
+                notificationView.setContent {
+                    LaunchNotification()
+                }
+            }
         }
 
-        glSurfaceView.initView()
-        glSurfaceView.setCocos2dxRenderer(Cocos2dxRenderer())
+        glSurfaceView.setEGLContextClientVersion(2)
+        glSurfaceView.setEGLConfigChooser(EGLConfigChooser())
 
-        editText.inputType = 145
+        glSurfaceView.initView()
+
+        val renderer = Cocos2dxRenderer(glSurfaceView)
+        glSurfaceView.setCocos2dxRenderer(renderer)
+
+        renderer.setFrameRate = mForceRefreshRate
+
+        val frameRate = mLimitedRefreshRate
+        if (frameRate != null) {
+            renderer.limitFrameRate(frameRate)
+        }
+
+        editText.inputType = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD
         glSurfaceView.cocos2dxEditText = editText
 
         return frameLayout
@@ -380,10 +444,32 @@ class GeometryDashActivity : AppCompatActivity(), Cocos2dxHelper.Cocos2dxHelperL
     private fun setupUIState() {
         requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_USER_LANDSCAPE
 
+        val preferenceUtils = PreferenceUtils.get(this)
+
         displayMode = DisplayMode.fromInt(
-            PreferenceUtils.get(this).getInt(PreferenceUtils.Key.DISPLAY_MODE)
+            preferenceUtils.getInt(PreferenceUtils.Key.DISPLAY_MODE)
         )
 
+        mAspectRatio = ratioForPreference(preferenceUtils.getString(PreferenceUtils.Key.CUSTOM_ASPECT_RATIO) ?: "16_9")
+        mScreenZoom = preferenceUtils.getInt(PreferenceUtils.Key.SCREEN_ZOOM) / 100.0f
+        mScreenZoomFit = preferenceUtils.getBoolean(PreferenceUtils.Key.SCREEN_ZOOM_FIT)
+
+        val limitedRefreshRate = preferenceUtils.getInt(PreferenceUtils.Key.LIMIT_FRAME_RATE).takeIf { it != 0 }
+        mLimitedRefreshRate = limitedRefreshRate
+
+        mForceRefreshRate = preferenceUtils.getBoolean(PreferenceUtils.Key.FORCE_HRR)
+        if (mForceRefreshRate && Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            val chosenDisplay = display.supportedModes?.maxByOrNull { it.refreshRate }
+            if (chosenDisplay != null) {
+                var chosenRefreshRate = chosenDisplay.refreshRate
+                println("setupUIState: Forcing a refresh rate of $chosenRefreshRate (display ${chosenDisplay.modeId})")
+
+                window.attributes.preferredRefreshRate = chosenRefreshRate
+            } else {
+                println("setupUIState could not find a display to select refresh rate of...")
+            }
+        }
+
         if (displayMode == DisplayMode.FULLSCREEN && Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
             window.attributes.layoutInDisplayCutoutMode = WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES
         }
@@ -413,19 +499,18 @@ class GeometryDashActivity : AppCompatActivity(), Cocos2dxHelper.Cocos2dxHelperL
 
     override fun onDestroy() {
         super.onDestroy()
-        unregisterReceivers()
         FMOD.close()
     }
 
     private fun resumeGame() {
         mIsRunning = true
-//        Cocos2dxHelper.onResume()
+        Cocos2dxHelper.onResume()
         mGLSurfaceView?.onResume()
     }
 
     private fun pauseGame() {
         mIsRunning = false
-//        Cocos2dxHelper.onPause()
+        Cocos2dxHelper.onPause()
         mGLSurfaceView?.onPause()
     }
 
@@ -456,25 +541,6 @@ class GeometryDashActivity : AppCompatActivity(), Cocos2dxHelper.Cocos2dxHelperL
         }
     }
 
-    private fun registerReceiver() {
-        unregisterReceivers()
-        try {
-            val filter = IntentFilter(Intent.ACTION_SCREEN_ON)
-            filter.addAction(Intent.ACTION_SCREEN_OFF)
-            filter.addAction(Intent.ACTION_USER_PRESENT)
-            mReceiver = BaseRobTopActivity.ReceiverScreen()
-            registerReceiver(mReceiver, filter)
-        } catch (_: Exception) {
-        }
-    }
-
-    private fun unregisterReceivers() {
-        if (mReceiver != null) {
-            unregisterReceiver(mReceiver)
-            mReceiver = null
-        }
-    }
-
     override fun runOnGLThread(runnable: Runnable) {
         mGLSurfaceView?.queueEvent(runnable)
     }
@@ -501,60 +567,123 @@ class GeometryDashActivity : AppCompatActivity(), Cocos2dxHelper.Cocos2dxHelperL
         TODO("Not yet implemented")
     }
 
-    private fun isAndroidEmulator(): Boolean {
-        Log.d(sTag, "model=" + Build.MODEL)
-        val product = Build.PRODUCT
-        Log.d(sTag, "product=$product")
-        var isEmulator = false
-        if (product != null) {
-            isEmulator = product == "sdk" || product.contains("_sdk") || product.contains("sdk_")
+    override fun onCapabilityAdded(capability: String): Boolean {
+        return when (capability) {
+            GeodeUtils.CAPABILITY_EXTENDED_INPUT -> {
+                mGLSurfaceView?.useKeyboardEvents = true
+                true
+            }
+            GeodeUtils.CAPABILITY_TIMESTAMP_INPUT -> {
+                mGLSurfaceView?.sendTimestampEvents = true
+                true
+            }
+            else -> false
         }
-        Log.d(sTag, "isEmulator=$isEmulator")
-        return isEmulator
     }
 
-    private fun getLoadTesting(): Boolean {
-        val preferences = PreferenceUtils.get(this)
-        return preferences.getBoolean(PreferenceUtils.Key.LOAD_TESTING)
-    }
+    /**
+     * Copies a mod from the launcher's assets to the Geode mods directory.
+     * This method is not recommended for casual use, the new mod will not be automatically removed.
+     */
+    private fun loadInternalMods() {
+        val internalModBase = "mods"
 
-    @SuppressLint("UnsafeDynamicallyLoadedCode")
-    private fun loadTestingLibraries() {
-        // clear data dir
-        val testDirPath = File(filesDir.path + File.separator + "testlib" + File.separator)
-        if (testDirPath.exists()) {
-            testDirPath.deleteRecursively()
+        val modListing = try {
+            assets.list(internalModBase)
+        } catch (_: IOException) {
+            emptyArray<String>()
         }
-        testDirPath.mkdir()
 
-        val dir = LaunchUtils.getBaseDirectory(this)
-        val testingPath = File(dir, "test")
+        val modDirectory = File(
+            LaunchUtils.getBaseDirectory(this),
+            "game/geode/mods"
+        )
 
-        testingPath.walk().forEach {
-            if (it.isFile) {
-                // welcome to the world of Android classloader permissions
-                val outputFile = File(testDirPath, it.name)
-                DownloadUtils.copyFile(
-                    FileInputStream(it),
-                    FileOutputStream(outputFile)
-                )
+        modDirectory.mkdirs()
 
-                try {
-                    println("Loading test library ${outputFile.name}")
-                    System.load(outputFile.path)
-                } catch (e: UnsatisfiedLinkError) {
-                    e.printStackTrace()
-                }
+        modListing?.forEach { fileName ->
+            if (fileName.endsWith(".geode")) {
+                val modOutput = File(modDirectory, fileName)
+
+                val mod = assets.open("$internalModBase/$fileName")
+                DownloadUtils.copyFile(mod, modOutput.outputStream())
+
+                println("Copied internal mod $fileName")
             }
         }
     }
 
-    override fun onCapabilityAdded(capability: String): Boolean {
-        if (capability == GeodeUtils.CAPABILITY_EXTENDED_INPUT) {
-            mGLSurfaceView?.useKeyboardEvents = true
-            return true
+    class EGLConfigChooser : GLSurfaceView.EGLConfigChooser {
+        // this comes from EGL14, but is unavailable on EGL10
+        // also EGL14 is incompatible with EGL10. so whatever
+        private var EGL_OPENGL_ES2_BIT: Int = 0x04
+
+        private data class ConfigValues(
+            val redSize: Int,
+            val greenSize: Int,
+            val blueSize: Int,
+            val alphaSize: Int,
+            val depthSize: Int,
+            val stencilSize: Int,
+        )
+
+        private fun getAttribValue(egl: EGL10, display: EGLDisplay, config: EGLConfig, attrib: Int): Int {
+            val value = IntArray(1)
+            egl.eglGetConfigAttrib(display, config, attrib, value)
+
+            return value[0]
         }
 
-        return false
+        private fun testConfig(egl: EGL10, display: EGLDisplay, attrib: ConfigValues): EGLConfig? {
+            val attribList = intArrayOf(
+                EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+                EGL10.EGL_RED_SIZE, attrib.redSize,
+                EGL10.EGL_GREEN_SIZE, attrib.greenSize,
+                EGL10.EGL_BLUE_SIZE, attrib.blueSize,
+                EGL10.EGL_ALPHA_SIZE, attrib.alphaSize,
+                EGL10.EGL_DEPTH_SIZE, attrib.depthSize,
+                EGL10.EGL_STENCIL_SIZE, attrib.stencilSize,
+                EGL10.EGL_NONE
+            )
+
+            val configs = arrayOfNulls<EGLConfig>(1)
+            val numConfigs = IntArray(1)
+
+            val res = egl.eglChooseConfig(display, attribList, configs, configs.size, numConfigs)
+            if (res && numConfigs[0] > 0 && configs[0] != null) {
+                return configs[0]
+            }
+
+            return null
+        }
+
+        private fun printConfig(egl: EGL10, display: EGLDisplay, config: EGLConfig) {
+            val id = getAttribValue(egl, display, config, EGL10.EGL_CONFIG_ID)
+            val red = getAttribValue(egl, display, config, EGL10.EGL_RED_SIZE)
+            val green = getAttribValue(egl, display, config, EGL10.EGL_GREEN_SIZE)
+            val blue = getAttribValue(egl, display, config, EGL10.EGL_BLUE_SIZE)
+            val alpha = getAttribValue(egl, display, config, EGL10.EGL_ALPHA_SIZE)
+            val depth = getAttribValue(egl, display, config, EGL10.EGL_DEPTH_SIZE)
+            val stencil = getAttribValue(egl, display, config, EGL10.EGL_STENCIL_SIZE)
+            println("EGLConfig $id: (red = $red, green = $green, blue = $blue, alpha = $alpha, depth = $depth, stencil = $stencil)")
+        }
+
+        override fun chooseConfig(egl: EGL10, display: EGLDisplay): EGLConfig {
+            val configs = listOf(
+                ConfigValues(8, 8, 8, 8, 16, 8),
+                ConfigValues(8, 8, 8, 0, 16, 8),
+                ConfigValues(5, 6, 5, 0, 16, 8),
+                ConfigValues(0, 0, 0, 0, 0, 0),
+            )
+
+            return configs.firstNotNullOf {
+                val config = testConfig(egl, display, it)
+                if (config != null) {
+                    printConfig(egl, display, config)
+                }
+
+                config
+            }
+        }
     }
 }

app/src/main/java/com/geode/launcher/LauncherFix.kt

@@ -1,7 +1,9 @@
 package com.geode.launcher
 
+import androidx.annotation.Keep
 import com.geode.launcher.utils.Constants
 
+@Keep
 object LauncherFix {
     fun loadLibrary() {
         System.loadLibrary(Constants.LAUNCHER_FIX_LIB_NAME)
@@ -10,4 +12,8 @@ object LauncherFix {
     external fun setDataPath(dataPath: String)
 
     external fun setOriginalDataPath(dataPath: String)
+
+    external fun performExceptionsRenaming()
+
+    external fun enableCustomSymbolList(symbolsPath: String)
 }

app/src/main/java/com/geode/launcher/MainActivity.kt

@@ -1,28 +1,16 @@
 package com.geode.launcher
 
-import android.content.ActivityNotFoundException
-import android.content.Context
 import android.content.Intent
-import android.os.Build
 import android.os.Bundle
-import android.provider.DocumentsContract
-import android.text.format.Formatter.formatShortFileSize
-import android.widget.Toast
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
 import androidx.compose.foundation.Image
-import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.interaction.PressInteraction
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.PlayArrow
-import androidx.compose.material.icons.filled.Refresh
 import androidx.compose.material.icons.filled.Settings
-import androidx.compose.material.icons.filled.Share
-import androidx.compose.material.icons.filled.Warning
 import androidx.compose.material3.*
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
@@ -34,51 +22,31 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.hapticfeedback.HapticFeedbackType
-import androidx.compose.ui.platform.LocalClipboardManager
 import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.platform.LocalHapticFeedback
-import androidx.compose.ui.platform.LocalUriHandler
-import androidx.compose.ui.platform.LocalViewConfiguration
 import androidx.compose.ui.res.painterResource
-import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.AnnotatedString
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import androidx.lifecycle.viewmodel.compose.viewModel
+import com.geode.launcher.main.*
 import com.geode.launcher.updater.ReleaseViewModel
 import com.geode.launcher.ui.theme.GeodeLauncherTheme
 import com.geode.launcher.ui.theme.LocalTheme
 import com.geode.launcher.ui.theme.Theme
-import com.geode.launcher.ui.theme.Typography
 import com.geode.launcher.utils.Constants
 import com.geode.launcher.utils.LaunchUtils
 import com.geode.launcher.utils.PreferenceUtils
-import com.geode.launcher.updater.ReleaseManager
-import com.geode.launcher.utils.GeodeUtils
-import com.geode.launcher.utils.useCountdownTimer
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.collectLatest
-import java.net.ConnectException
-import java.net.UnknownHostException
-
-data class LoadFailureInfo(
-    val title: LaunchUtils.LauncherError,
-    val description: String? = null,
-    val extendedMessage: String? = null
-)
+import com.geode.launcher.utils.GamePackageUtils
 
 class MainActivity : ComponentActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         enableEdgeToEdge()
+        clearDownloadedApks(this)
 
         super.onCreate(savedInstanceState)
 
-        val gdInstalled = LaunchUtils.isGeometryDashInstalled(packageManager)
+        val gdInstalled = GamePackageUtils.isGameInstalled(packageManager)
         val geodeInstalled = LaunchUtils.isGeodeInstalled(this)
 
         val returnMessage = intent.extras?.getString(LaunchUtils.LAUNCHER_KEY_RETURN_MESSAGE)
@@ -94,6 +62,15 @@ class MainActivity : ComponentActivity() {
             LoadFailureInfo(LaunchUtils.LauncherError.CRASHED)
         } else { null }
 
+        val redirectToAlt = PreferenceUtils.get(this).getBoolean(PreferenceUtils.Key.ENABLE_REDESIGN)
+        if (redirectToAlt) {
+            val launchIntent = Intent(this, AltMainActivity::class.java)
+            launchIntent.putExtras(intent)
+            startActivity(launchIntent)
+
+            return
+        }
+
         setContent {
             val themeOption by PreferenceUtils.useIntPreference(PreferenceUtils.Key.THEME)
             val theme = Theme.fromInt(themeOption)
@@ -121,660 +98,6 @@ class MainActivity : ComponentActivity() {
     }
 }
 
-@Composable
-fun LauncherUpdateIndicator(modifier: Modifier = Modifier, openTo: String, onDismiss: () -> Unit) {
-    val uriHandler = LocalUriHandler.current
-
-    ElevatedCard(modifier) {
-        Column(
-            // buttons add enough padding already, lower to compensate
-            modifier = Modifier.padding(
-                top = 20.dp,
-                start = 12.dp,
-                end = 12.dp,
-                bottom = 8.dp
-            ),
-            verticalArrangement = Arrangement.spacedBy(12.dp),
-        ) {
-            Text(
-                stringResource(R.string.launcher_update_available),
-                modifier = Modifier.padding(horizontal = 10.dp)
-            )
-
-            Row(modifier = Modifier.align(Alignment.End)) {
-                TextButton(onClick = onDismiss) {
-                    Text(stringResource(R.string.launcher_update_dismiss))
-                }
-
-                Spacer(Modifier.size(4.dp))
-
-                TextButton(onClick = { uriHandler.openUri(openTo) }) {
-                    Text(stringResource(R.string.launcher_download))
-                }
-            }
-
-
-        }
-    }
-}
-
-@Composable
-fun UpdateProgressIndicator(
-    message: String,
-    releaseViewModel: ReleaseViewModel,
-    modifier: Modifier = Modifier,
-    progress: (() -> Float)? = null
-) {
-    Column(
-        verticalArrangement = Arrangement.Center,
-        horizontalAlignment = Alignment.Start,
-        modifier = modifier
-    ) {
-        Text(message)
-
-        Spacer(modifier = Modifier.padding(4.dp))
-
-        if (progress == null) {
-            LinearProgressIndicator()
-        } else {
-            LinearProgressIndicator(progress = progress)
-        }
-
-        TextButton(
-            onClick = {
-                releaseViewModel.cancelUpdate()
-            },
-            modifier = Modifier.offset((-12).dp)
-        ) {
-            Text(stringResource(R.string.release_fetch_button_cancel))
-        }
-    }
-}
-
-@Composable
-fun UpdateMessageIndicator(
-    message: String,
-    releaseViewModel: ReleaseViewModel,
-    modifier: Modifier = Modifier,
-    allowRetry: Boolean = false
-) {
-    Column(
-        horizontalAlignment = Alignment.CenterHorizontally,
-        modifier = modifier
-    ) {
-        Text(
-            message,
-            textAlign = TextAlign.Center,
-        )
-
-        Spacer(modifier = Modifier.padding(4.dp))
-
-        if (allowRetry) {
-            OutlinedButton(
-                onClick = {
-                    releaseViewModel.runReleaseCheck(true)
-                },
-            ) {
-                Icon(
-                    Icons.Filled.Refresh,
-                    contentDescription = stringResource(R.string.launcher_retry_icon_alt)
-                )
-                Spacer(Modifier.size(ButtonDefaults.IconSpacing))
-                Text(stringResource(R.string.release_fetch_button_retry))
-            }
-        }
-    }
-
-}
-
-@Composable
-fun UpdateWarning(inSafeMode: Boolean = false, onDismiss: () -> Unit) {
-    val context = LocalContext.current
-    val packageManager = context.packageManager
-
-    val gdVersionCode = remember { LaunchUtils.getGeometryDashVersionCode(packageManager) }
-    val gdVersionString = remember { LaunchUtils.getGeometryDashVersionString(packageManager) }
-
-    var lastDismissedVersion by PreferenceUtils.useLongPreference(
-        preferenceKey = PreferenceUtils.Key.DISMISSED_GJ_UPDATE
-    )
-
-    val canDismissRelease = gdVersionCode >= Constants.SUPPORTED_VERSION_CODE
-    val shouldDismiss = canDismissRelease && gdVersionCode == lastDismissedVersion
-
-    if (gdVersionCode != Constants.SUPPORTED_VERSION_CODE && !shouldDismiss) {
-        AlertDialog(
-            icon = {
-                Icon(
-                    Icons.Filled.Warning,
-                    contentDescription = stringResource(R.string.launcher_warning_icon_alt)
-                )
-            },
-            title = {
-                Text(stringResource(R.string.launcher_unsupported_version_title))
-            },
-            text = {
-                val message = if (gdVersionCode >= Constants.SUPPORTED_VERSION_CODE) {
-                    R.string.launcher_unsupported_version_description
-                } else {
-                    R.string.launcher_outdated_version_description
-                }
-
-                Text(stringResource(
-                    message, gdVersionString, Constants.SUPPORTED_VERSION_STRING
-                ))
-            },
-            confirmButton = {
-                TextButton(onClick = {
-                    onDismiss()
-                    lastDismissedVersion = gdVersionCode
-
-                    onLaunch(context, inSafeMode)
-                }) {
-                    Text(stringResource(R.string.message_box_accept))
-                }
-            },
-            dismissButton = {
-                TextButton(onClick = { onDismiss() }) {
-                    Text(stringResource(R.string.message_box_cancel))
-                }
-            },
-            onDismissRequest = { onDismiss() }
-        )
-    } else {
-        LaunchedEffect(gdVersionCode) {
-            onLaunch(context, inSafeMode)
-        }
-    }
-}
-
-@Composable
-fun SafeModeDialog(onDismiss: () -> Unit, onLaunch: () -> Unit) {
-    AlertDialog(
-        icon = {
-            Icon(
-                Icons.Filled.Warning,
-                contentDescription = stringResource(R.string.launcher_warning_icon_alt)
-            )
-        },
-        title = { Text(stringResource(R.string.safe_mode_enable_title)) },
-        text = { Text(stringResource(R.string.safe_mode_enable_description)) },
-        dismissButton = {
-            TextButton(onClick = onDismiss) {
-                Text(stringResource(R.string.message_box_cancel))
-            }
-        },
-        confirmButton = {
-            TextButton(onClick = onLaunch) {
-                Text(stringResource(R.string.message_box_continue))
-            }
-        },
-        onDismissRequest = onDismiss
-    )
-}
-
-@Composable
-fun UpdateCard(releaseViewModel: ReleaseViewModel, modifier: Modifier = Modifier) {
-    val context = LocalContext.current
-
-    val releaseState by releaseViewModel.uiState.collectAsState()
-
-    when (val state = releaseState) {
-        is ReleaseViewModel.ReleaseUIState.Failure -> {
-            val message = when (state.exception) {
-                is UnknownHostException, is ConnectException ->
-                    stringResource(R.string.release_fetch_no_internet)
-                is ReleaseManager.UpdateException -> {
-                    when (state.exception.reason) {
-                        ReleaseManager.UpdateException.Reason.EXTERNAL_FILE_IN_USE -> stringResource(
-                            R.string.release_fetch_manual_check_required
-                        )
-                        else -> state.exception.message
-                    }
-                }
-                else -> state.exception.message
-            }
-
-            UpdateMessageIndicator(
-                stringResource(R.string.release_fetch_failed, message ?: ""),
-                modifier = modifier,
-                allowRetry = true,
-                releaseViewModel = releaseViewModel
-            )
-        }
-        is ReleaseViewModel.ReleaseUIState.InDownload -> {
-            val downloaded = remember(state.downloaded) {
-                formatShortFileSize(context, state.downloaded)
-            }
-
-            val outOf = remember(state.outOf) {
-                formatShortFileSize(context, state.outOf)
-            }
-
-            UpdateProgressIndicator(
-                stringResource(
-                    R.string.release_fetch_downloading,
-                    downloaded,
-                    outOf
-                ),
-                modifier = modifier,
-                releaseViewModel = releaseViewModel,
-                progress = {
-                    val progress = state.downloaded / state.outOf.toDouble()
-                    progress.toFloat()
-                }
-            )
-        }
-        is ReleaseViewModel.ReleaseUIState.InUpdateCheck -> {
-            UpdateProgressIndicator(
-                stringResource(R.string.release_fetch_in_progress),
-                modifier = modifier,
-                releaseViewModel = releaseViewModel
-            )
-        }
-        is ReleaseViewModel.ReleaseUIState.Finished -> {
-            if (state.hasUpdated) {
-                UpdateMessageIndicator(
-                    stringResource(R.string.release_fetch_success),
-                    modifier = modifier,
-                    releaseViewModel = releaseViewModel
-                )
-            }
-        }
-        is ReleaseViewModel.ReleaseUIState.Cancelled -> {
-            if (state.isCancelling) {
-                UpdateProgressIndicator(
-                    stringResource(R.string.release_fetch_cancelling),
-                    modifier = modifier,
-                    releaseViewModel = releaseViewModel
-                )
-            } else {
-                UpdateMessageIndicator(
-                    stringResource(R.string.release_fetch_cancelled),
-                    modifier = modifier,
-                    allowRetry = true,
-                    releaseViewModel = releaseViewModel
-                )
-            }
-        }
-    }
-
-    val nextUpdate by releaseViewModel.nextLauncherUpdate.collectAsState()
-    val nextUpdateValue = nextUpdate
-
-    if (!releaseViewModel.isInUpdate && nextUpdateValue != null) {
-        val updateUrl = nextUpdateValue.getLauncherDownload()?.browserDownloadUrl
-            ?: nextUpdateValue.htmlUrl
-
-        LauncherUpdateIndicator(
-            modifier = modifier,
-            openTo = updateUrl,
-            onDismiss = {
-                releaseViewModel.dismissLauncherUpdate()
-            }
-        )
-    }
-}
-
-@Composable
-fun ErrorInfoBody(failureReason: LaunchUtils.LauncherError, modifier: Modifier = Modifier) {
-    val headline = when (failureReason) {
-        LaunchUtils.LauncherError.LINKER_NEEDS_64BIT,
-        LaunchUtils.LauncherError.LINKER_NEEDS_32BIT -> stringResource(R.string.load_failed_abi_error)
-        LaunchUtils.LauncherError.LINKER_FAILED -> stringResource(R.string.load_failed_link_error_description)
-        LaunchUtils.LauncherError.GENERIC -> stringResource(R.string.load_failed_generic_error_description)
-        LaunchUtils.LauncherError.CRASHED -> stringResource(R.string.load_failed_crashed_description)
-    }
-
-    val recommendations = when (failureReason) {
-        LaunchUtils.LauncherError.LINKER_NEEDS_64BIT -> listOf(
-            stringResource(R.string.load_failed_recommendation_reinstall),
-            stringResource(R.string.load_failed_recommendation_switch_64bit_abi),
-        )
-        LaunchUtils.LauncherError.LINKER_NEEDS_32BIT -> listOf(
-            stringResource(R.string.load_failed_recommendation_reinstall),
-            stringResource(R.string.load_failed_recommendation_switch_32bit_abi),
-        )
-        LaunchUtils.LauncherError.LINKER_FAILED -> listOf(
-            stringResource(R.string.load_failed_recommendation_reinstall),
-            stringResource(R.string.load_failed_recommendation_update),
-        )
-        LaunchUtils.LauncherError.GENERIC -> listOf(
-            stringResource(R.string.load_failed_recommendation_reinstall),
-            stringResource(R.string.load_failed_recommendation_update),
-            stringResource(R.string.load_failed_recommendation_report)
-        )
-        LaunchUtils.LauncherError.CRASHED -> listOf(
-            stringResource(R.string.load_failed_recommendation_safe_mode),
-            stringResource(R.string.load_failed_recommendation_report)
-        )
-    }
-
-    Column(modifier = modifier) {
-        Text(headline)
-
-        recommendations.forEach { r ->
-            Text("\u2022\u00A0\u00A0$r")
-        }
-    }
-}
-
-@Composable
-fun ErrorInfoTitle(failureReason: LaunchUtils.LauncherError) {
-    val message = when (failureReason) {
-        LaunchUtils.LauncherError.LINKER_NEEDS_64BIT,
-        LaunchUtils.LauncherError.LINKER_NEEDS_32BIT,
-        LaunchUtils.LauncherError.LINKER_FAILED -> stringResource(R.string.load_failed_link_error)
-        LaunchUtils.LauncherError.GENERIC -> stringResource(R.string.load_failed_generic_error)
-        LaunchUtils.LauncherError.CRASHED -> stringResource(R.string.load_failed_crashed)
-    }
-
-    Row(
-        horizontalArrangement = Arrangement.spacedBy(10.dp),
-        verticalAlignment = Alignment.CenterVertically
-    ) {
-        Icon(
-            painterResource(R.drawable.icon_error),
-            contentDescription = stringResource(R.string.launcher_error_icon_alt),
-            modifier = Modifier.size(28.dp)
-        )
-        Text(message, style = Typography.headlineMedium)
-    }
-
-}
-
-fun onShareCrash(context: Context) {
-    val lastCrash = LaunchUtils.getLastCrash(context)
-    if (lastCrash == null) {
-        Toast.makeText(context, R.string.launcher_error_export_missing, Toast.LENGTH_SHORT).show()
-        return
-    }
-
-    val baseDirectory = LaunchUtils.getBaseDirectory(context)
-
-    val providerLocation = lastCrash.toRelativeString(baseDirectory)
-    val documentsPath = "${UserDirectoryProvider.ROOT}${providerLocation}"
-
-    val uri = DocumentsContract.buildDocumentUri("${context.packageName}.user", documentsPath)
-
-    val shareIntent = Intent(Intent.ACTION_SEND).apply {
-        putExtra(Intent.EXTRA_STREAM, uri)
-        type = "application/octet-stream"
-    }
-
-    try {
-        context.startActivity(shareIntent)
-    } catch (_: ActivityNotFoundException) {
-        Toast.makeText(context, R.string.no_activity_found, Toast.LENGTH_SHORT).show()
-    }
-}
-
-fun onShowLogs(context: Context) {
-    val launchIntent = Intent(context, ApplicationLogsActivity::class.java)
-    context.startActivity(launchIntent)
-}
-
-@OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class)
-@Composable
-fun ErrorInfoSheet(failureInfo: LoadFailureInfo, onDismiss: () -> Unit) {
-    val sheetState = rememberModalBottomSheetState()
-
-    ModalBottomSheet(onDismissRequest = { onDismiss() }, sheetState = sheetState) {
-        Column(modifier = Modifier
-            .padding(horizontal = 24.dp)
-            .verticalScroll(rememberScrollState())
-        ) {
-            ErrorInfoTitle(failureInfo.title)
-
-            Spacer(Modifier.size(16.dp))
-
-            ErrorInfoBody(failureInfo.title)
-
-            if (failureInfo.description != null) {
-                Column(modifier = Modifier.padding(vertical = 8.dp)) {
-                    Text(
-                        stringResource(R.string.launcher_error_details),
-                        style = Typography.headlineSmall
-                    )
-
-                    Spacer(Modifier.size(8.dp))
-
-                    Text(
-                        failureInfo.description,
-                        fontFamily = FontFamily.Monospace,
-                        style = Typography.bodyMedium
-                    )
-
-                    Spacer(Modifier.size(4.dp))
-
-                    Text(
-                        stringResource(R.string.launcher_error_device_info, Build.MODEL, Build.VERSION.RELEASE),
-                        style = Typography.labelMedium
-                    )
-                }
-            }
-
-            val clipboardManager = LocalClipboardManager.current
-            val context = LocalContext.current
-
-            FlowRow(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(vertical = 8.dp),
-                horizontalArrangement = Arrangement.spacedBy(
-                    12.dp, alignment = Alignment.CenterHorizontally
-                )
-            ) {
-                if (failureInfo.description != null) {
-                    Button(onClick = { onShowLogs(context) }) {
-                        Icon(
-                            painterResource(R.drawable.icon_description),
-                            contentDescription = null
-                        )
-                        Spacer(Modifier.size(ButtonDefaults.IconSpacing))
-                        Text(stringResource(R.string.launcher_error_view_logs))
-                    }
-
-                    FilledTonalButton(onClick = {
-                        val message = failureInfo.extendedMessage ?: failureInfo.description
-                        clipboardManager.setText(AnnotatedString(message))
-                    }) {
-                        Icon(
-                            painterResource(R.drawable.icon_content_copy),
-                            contentDescription = null
-                        )
-                        Spacer(Modifier.size(ButtonDefaults.IconSpacing))
-                        Text(stringResource(R.string.launcher_error_copy))
-                    }
-                } else {
-                    Button(onClick = { onShareCrash(context) }) {
-                        Icon(
-                            Icons.Filled.Share,
-                            contentDescription = null
-                        )
-                        Spacer(Modifier.size(ButtonDefaults.IconSpacing))
-                        Text(stringResource(R.string.launcher_error_export_crash))
-                    }
-
-                    FilledTonalButton(onClick = { onShowLogs(context) }) {
-                        Icon(
-                            painterResource(R.drawable.icon_description),
-                            contentDescription = null
-                        )
-                        Spacer(Modifier.size(ButtonDefaults.IconSpacing))
-                        Text(stringResource(R.string.launcher_error_view_logs))
-                    }
-                }
-            }
-
-            Spacer(Modifier.size(8.dp))
-        }
-    }
-}
-
-fun onLaunch(context: Context, safeMode: Boolean = false) {
-    if (safeMode) {
-        GeodeUtils.setAdditionalLaunchArguments(GeodeUtils.ARGUMENT_SAFE_MODE)
-    } else {
-        GeodeUtils.clearLaunchArguments()
-    }
-
-    val launchIntent = Intent(context, GeometryDashActivity::class.java)
-    launchIntent.flags = Intent.FLAG_ACTIVITY_CLEAR_TASK or Intent.FLAG_ACTIVITY_NEW_TASK
-
-    context.startActivity(launchIntent)
-}
-
-fun onSettings(context: Context) {
-    val launchIntent = Intent(context, SettingsActivity::class.java)
-    context.startActivity(launchIntent)
-}
-
-suspend fun showFailureSnackbar(
-    context: Context,
-    loadFailureInfo: LoadFailureInfo,
-    snackbarHostState: SnackbarHostState,
-    onActionPerformed: () -> Unit
-) {
-    val message = if (loadFailureInfo.title == LaunchUtils.LauncherError.CRASHED) {
-        context.getString(R.string.launcher_crashed)
-    } else {
-        context.getString(R.string.launcher_failed_to_load)
-    }
-
-    val res = snackbarHostState.showSnackbar(
-        message = message,
-        actionLabel = context.getString(R.string.launcher_error_more),
-        duration = SnackbarDuration.Indefinite,
-    )
-
-    when (res) {
-        SnackbarResult.ActionPerformed -> {
-            onActionPerformed()
-        }
-        SnackbarResult.Dismissed -> {}
-    }
-}
-
-@Composable
-fun PlayButton(
-    stopAutomaticLaunch: Boolean,
-    blockLaunch: Boolean,
-    onPlayGame: (Boolean) -> Unit
-) {
-    val context = LocalContext.current
-
-    var showSafeModeDialog by remember { mutableStateOf(false) }
-    var launchInSafeMode by remember { mutableStateOf(false) }
-
-    val shouldAutomaticallyLaunch by PreferenceUtils.useBooleanPreference(
-        preferenceKey = PreferenceUtils.Key.LOAD_AUTOMATICALLY
-    )
-
-    if (shouldAutomaticallyLaunch && !stopAutomaticLaunch && !showSafeModeDialog) {
-        val countdownTimer = useCountdownTimer(
-            time = 3000,
-            onCountdownFinish = { onPlayGame(launchInSafeMode) }
-        )
-
-        if (countdownTimer != 0L) {
-            Text(
-                pluralStringResource(
-                    R.plurals.automatically_load_countdown,
-                    countdownTimer.toInt(),
-                    countdownTimer
-                ),
-                style = Typography.bodyMedium,
-                color = MaterialTheme.colorScheme.onSecondaryContainer,
-            )
-            Spacer(Modifier.size(12.dp))
-        }
-    }
-
-    // compose apis don't provide a good way of adding long press to a button
-    val interactionSource = remember { MutableInteractionSource() }
-    val viewConfiguration = LocalViewConfiguration.current
-    val haptics = LocalHapticFeedback.current
-
-    LaunchedEffect(interactionSource) {
-        interactionSource.interactions.collectLatest { interaction ->
-            when (interaction) {
-                is PressInteraction.Press -> {
-                    launchInSafeMode = false
-
-                    delay(viewConfiguration.longPressTimeoutMillis)
-
-                    // perform a second delay to make the action more obvious
-                    haptics.performHapticFeedback(HapticFeedbackType.LongPress)
-                    delay(viewConfiguration.longPressTimeoutMillis)
-
-                    haptics.performHapticFeedback(HapticFeedbackType.LongPress)
-
-                    showSafeModeDialog = true
-                }
-
-                is PressInteraction.Release -> {
-                    if (!showSafeModeDialog) {
-                        onPlayGame(launchInSafeMode)
-                    }
-                }
-            }
-        }
-    }
-
-    Row {
-        Button(
-            onClick = { },
-            enabled = !blockLaunch,
-            interactionSource = interactionSource
-        ) {
-            Icon(
-                Icons.Filled.PlayArrow,
-                contentDescription = context.getString(R.string.launcher_launch_icon_alt)
-            )
-            Spacer(Modifier.size(ButtonDefaults.IconSpacing))
-            Text(context.getString(R.string.launcher_launch))
-        }
-        Spacer(Modifier.size(2.dp))
-        IconButton(onClick = { onSettings(context) }) {
-            Icon(
-                Icons.Filled.Settings,
-                contentDescription = context.getString(R.string.launcher_settings_icon_alt)
-            )
-        }
-    }
-
-    if (showSafeModeDialog) {
-        SafeModeDialog(
-            onDismiss = {
-                launchInSafeMode = false
-                showSafeModeDialog = false
-            },
-            onLaunch = {
-                launchInSafeMode = true
-
-                onPlayGame(true)
-
-                showSafeModeDialog = false
-            }
-        )
-    }
-}
-
-@Composable
-fun LaunchBlockedLabel(text: String) {
-    val context = LocalContext.current
-
-    Column(horizontalAlignment = Alignment.CenterHorizontally) {
-        Text(text, modifier = Modifier.padding(12.dp))
-        OutlinedButton(onClick = { onSettings(context) }) {
-            Icon(Icons.Filled.Settings, contentDescription = null)
-            Spacer(Modifier.size(ButtonDefaults.IconSpacing))
-            Text(context.getString(R.string.launcher_settings))
-        }
-    }
-}
-
 @Composable
 fun MainScreen(
     gdInstalled: Boolean = true,
@@ -788,14 +111,14 @@ fun MainScreen(
     val autoUpdateState by releaseViewModel.uiState.collectAsState()
 
     val geodeJustInstalled = (autoUpdateState as? ReleaseViewModel.ReleaseUIState.Finished)
-        ?.hasUpdated ?: false
+        ?.hasUpdated == true
     val geodeInstalled = geodePreinstalled || geodeJustInstalled
 
     var beginLaunch by remember { mutableStateOf(false) }
     var launchInSafeMode by remember { mutableStateOf(false) }
 
     LaunchedEffect(shouldUpdate) {
-        if (shouldUpdate && !releaseViewModel.hasPerformedCheck) {
+        if (shouldUpdate && !releaseViewModel.hasPerformedCheck && gdInstalled) {
             releaseViewModel.runReleaseCheck()
         } else {
             releaseViewModel.useGlobalCheckState()
@@ -836,7 +159,7 @@ fun MainScreen(
             Image(
                 painter = painterResource(id = R.drawable.geode_logo),
                 contentDescription = context.getString(R.string.launcher_logo_alt),
-                modifier = Modifier.size(136.dp, 136.dp)
+                modifier = Modifier.size(100.dp, 100.dp)
             )
             Text(
                 context.getString(R.string.launcher_title),
@@ -847,11 +170,15 @@ fun MainScreen(
             when {
                 gdInstalled && geodeInstalled -> {
                     val gdVersion = remember {
-                        LaunchUtils.getGeometryDashVersionCode(context.packageManager)
+                        GamePackageUtils.getGameVersionCode(context.packageManager)
                     }
 
-                    if (gdVersion < Constants.SUPPORTED_VERSION_CODE) {
-                        LaunchBlockedLabel(stringResource(R.string.game_outdated))
+                    if (gdVersion < Constants.SUPPORTED_VERSION_CODE_MIN) {
+                        val versionName = remember {
+                            GamePackageUtils.getUnifiedVersionName(context.packageManager)
+                        }
+
+                        LaunchBlockedLabel(stringResource(R.string.game_outdated, versionName))
                     } else {
                         val stopLaunch = releaseViewModel.isInUpdate || hasError
                         PlayButton(
@@ -862,6 +189,10 @@ fun MainScreen(
                                 beginLaunch = true
                             },
                         )
+
+                        if (gdVersion < Constants.SUPPORTED_VERSION_CODE_MIN_WARNING) {
+                            UnsupportedVersionWarning()
+                        }
                     }
                 }
                 gdInstalled -> {

app/src/main/java/com/geode/launcher/SettingsComponents.kt

@@ -1,366 +0,0 @@
-package com.geode.launcher
-
-import android.content.Context
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.selection.toggleable
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Clear
-import androidx.compose.material3.AlertDialog
-import androidx.compose.material3.Card
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.OutlinedTextField
-import androidx.compose.material3.RadioButton
-import androidx.compose.material3.Switch
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.semantics.Role
-import androidx.compose.ui.text.input.KeyboardType
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.window.Dialog
-import com.geode.launcher.ui.theme.GeodeLauncherTheme
-import com.geode.launcher.ui.theme.Typography
-import com.geode.launcher.utils.PreferenceUtils
-
-
-fun toggleSetting(context: Context, preferenceKey: PreferenceUtils.Key): Boolean {
-    val preferences = PreferenceUtils.get(context)
-
-    return preferences.toggleBoolean(preferenceKey)
-}
-
-fun getSetting(context: Context, preferenceKey: PreferenceUtils.Key): Boolean {
-    val preferences = PreferenceUtils.get(context)
-
-    return preferences.getBoolean(preferenceKey)
-}
-
-@Composable
-fun OptionsGroup(title: String, content: @Composable () -> Unit) {
-    Column {
-        Text(
-            title,
-            style = Typography.titleMedium,
-            modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp),
-        )
-        content()
-    }
-}
-
-@Composable
-fun SettingsSelectCard(
-    title: String,
-    dialogTitle: String,
-    maxVal: Int,
-    preferenceKey: PreferenceUtils.Key,
-    toLabel: @Composable (Int) -> String,
-    extraSelectBehavior: ((Int) -> Unit)? = null
-) {
-    val preferenceValue by PreferenceUtils.useIntPreference(preferenceKey)
-
-    var showDialog by remember { mutableStateOf(false) }
-
-    OptionsCard(
-        title = { OptionsTitle(title = title) },
-        modifier = Modifier
-            .clickable(
-                onClick = {
-                    showDialog = true
-                },
-                role = Role.Button
-            )
-    ) {
-        Text(toLabel(preferenceValue))
-    }
-
-    if (showDialog) {
-        val context = LocalContext.current
-
-        SelectDialog(
-            title = dialogTitle,
-            onDismissRequest = {
-                showDialog = false
-            },
-            onSelect = { selected ->
-                showDialog = false
-                PreferenceUtils.get(context)
-                    .setInt(preferenceKey, selected)
-                extraSelectBehavior?.invoke(selected)
-            },
-            initialValue = preferenceValue,
-            toLabel = toLabel,
-            optionsCount = 0..maxVal
-        )
-    }
-}
-
-@Composable
-fun SettingsStringCard(
-    title: String,
-    dialogTitle: String,
-    preferenceKey: PreferenceUtils.Key,
-    filterInput: ((String) -> String)? = null
-) {
-    var preferenceValue by PreferenceUtils.useStringPreference(preferenceKey)
-
-    var showDialog by remember { mutableStateOf(false) }
-
-    OptionsCard(
-        title = {
-            OptionsTitle(title = title, description = preferenceValue)
-        },
-        modifier = Modifier
-            .clickable(
-                onClick = {
-                    showDialog = true
-                },
-                role = Role.Button
-            )
-    ) { }
-
-    if (showDialog) {
-        StringDialog(
-            title = dialogTitle,
-            onDismissRequest = { showDialog = false },
-            onSelect = {
-                preferenceValue = it
-                showDialog = false
-            },
-            initialValue = preferenceValue ?: "",
-            filterInput = filterInput
-        )
-    }
-}
-
-@Composable
-fun StringDialog(
-    title: String,
-    onDismissRequest: () -> Unit,
-    onSelect: (String) -> Unit,
-    initialValue: String,
-    filterInput: ((String) -> String)? = null
-) {
-    var enteredValue by remember { mutableStateOf(initialValue) }
-
-    AlertDialog(
-        onDismissRequest = { onDismissRequest() },
-        title = {
-            Text(title)
-        },
-        text = {
-            OutlinedTextField(
-                value = enteredValue,
-                onValueChange = {
-                    enteredValue = filterInput?.invoke(it) ?: it
-                },
-                singleLine = true,
-                keyboardOptions = KeyboardOptions(
-                    keyboardType = KeyboardType.Ascii,
-                    autoCorrect = false
-                ),
-                trailingIcon = {
-                    if (enteredValue.isNotEmpty()) {
-                        IconButton(onClick = { enteredValue = "" }) {
-                            Icon(
-                                Icons.Filled.Clear,
-                                contentDescription = stringResource(R.string.preference_text_clear)
-                            )
-                        }
-                    }
-                }
-            )
-        },
-        confirmButton = {
-            TextButton(onClick = { onSelect(enteredValue) }) {
-                Text(stringResource(R.string.message_box_accept))
-            }
-        },
-        dismissButton = {
-            TextButton(onClick = onDismissRequest) {
-                Text(stringResource(R.string.message_box_cancel))
-            }
-        },
-    )
-}
-
-@Composable
-fun <T> SelectDialog(
-    title: String,
-    onDismissRequest: () -> Unit,
-    onSelect: (T) -> Unit,
-    initialValue: T,
-    toLabel: @Composable (T) -> String,
-    optionsCount: Iterable<T>,
-) {
-    var selectedValue by remember { mutableStateOf(initialValue) }
-
-    Dialog(onDismissRequest = onDismissRequest) {
-        Card(
-            shape = RoundedCornerShape(16.dp)
-        ) {
-            // styling a dialog is actually a little hard if you're doing what i'm doing
-            // maybe there's a better way to make these padding values...
-            Column {
-                Text(
-                    title,
-                    style = Typography.titleLarge,
-                    modifier = Modifier.padding(
-                        start = 28.dp,
-                        top = 24.dp,
-                        bottom = 12.dp
-                    )
-                )
-
-                // do not give the row or column padding!! it messes up the selection effect
-                optionsCount.forEach { id ->
-                    Row(
-                        verticalAlignment = Alignment.CenterVertically,
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .clickable(
-                                onClick = { selectedValue = id },
-                                role = Role.RadioButton
-                            )
-                            .padding(horizontal = 12.dp)
-                    ) {
-                        RadioButton(
-                            selected = selectedValue == id,
-                            onClick = { selectedValue = id }
-                        )
-                        Text(
-                            toLabel(id),
-                            style = Typography.bodyMedium
-                        )
-                    }
-                }
-
-                Row(
-                    horizontalArrangement = Arrangement.End,
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(
-                            bottom = 16.dp,
-                            end = 16.dp,
-                            top = 4.dp
-                        )
-                ) {
-                    TextButton(onClick = onDismissRequest) {
-                        Text(stringResource(R.string.message_box_cancel))
-                    }
-
-                    TextButton(onClick = { onSelect(selectedValue) }) {
-                        Text(stringResource(R.string.message_box_accept))
-                    }
-                }
-            }
-        }
-    }
-}
-
-@Composable
-fun OptionsButton(title: String, description: String? = null, onClick: () -> Unit) {
-    OptionsCard(
-        title = {
-            OptionsTitle(
-                title = title,
-                description = description
-            )
-        },
-        modifier = Modifier
-            .clickable(onClick = onClick, role = Role.Button)
-    ) { }
-}
-
-@Composable
-fun SettingsCard(title: String, description: String? = null, preferenceKey: PreferenceUtils.Key) {
-    val context = LocalContext.current
-    val settingEnabled = remember {
-        mutableStateOf(getSetting(context, preferenceKey))
-    }
-
-    OptionsCard(
-        title = {
-            OptionsTitle(
-                Modifier.fillMaxWidth(0.75f),
-                title = title,
-                description = description
-            )
-        },
-        modifier = Modifier.toggleable(
-            value = settingEnabled.value,
-            onValueChange = { settingEnabled.value = toggleSetting(context, preferenceKey) },
-            role = Role.Switch,
-        )
-    ) {
-        Switch(checked = settingEnabled.value, onCheckedChange = null)
-    }
-}
-
-@Composable
-fun OptionsTitle(modifier: Modifier = Modifier, title: String, description: String? = null) {
-    Column(
-        modifier,
-        verticalArrangement = Arrangement.spacedBy(4.dp),
-    ) {
-        Text(title)
-        if (!description.isNullOrEmpty()) {
-            Text(
-                description,
-                style = Typography.labelMedium,
-                color = MaterialTheme.colorScheme.onSecondaryContainer
-            )
-        }
-    }
-}
-
-@Composable
-fun OptionsCard(modifier: Modifier = Modifier, title: @Composable () -> Unit, content: @Composable () -> Unit) {
-    Row(
-        modifier
-            .fillMaxWidth()
-            .height(64.dp)
-            .padding(horizontal = 16.dp),
-        Arrangement.SpaceBetween,
-        Alignment.CenterVertically,
-    ) {
-        title()
-        content()
-    }
-}
-
-@Preview(showBackground = true)
-@Composable
-fun OptionsCardPreview() {
-    GeodeLauncherTheme {
-        OptionsGroup(title = "Preview Group") {
-            SettingsCard(
-                title = "Load files from /test",
-                description = "Very long testing description goes here. It is incredibly long, it should wrap onto a new line.",
-                preferenceKey = PreferenceUtils.Key.LOAD_TESTING
-            )
-            SettingsCard(
-                title = "Testing option 2",
-                preferenceKey = PreferenceUtils.Key.LOAD_AUTOMATICALLY
-            )
-        }
-    }
-}

app/src/main/java/com/geode/launcher/UserDirectoryProvider.kt

@@ -40,7 +40,7 @@ class UserDirectoryProvider : DocumentsProvider() {
 
     override fun onCreate(): Boolean {
         val context = context ?: return false
-        rootDir = LaunchUtils.getBaseDirectory(context)
+        rootDir = LaunchUtils.getBaseDirectory(context, true)
 
         return true
     }

app/src/main/java/com/geode/launcher/log/LogLine.kt

@@ -5,6 +5,7 @@ import kotlinx.datetime.Instant
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.toJavaInstant
 import kotlinx.datetime.toLocalDateTime
+import okio.Buffer
 import okio.BufferedSource
 import java.io.IOException
 
@@ -161,7 +162,7 @@ data class LogLine(
                 };
             */
 
-            /* val payloadLength = */ source.readShortLe()
+            val payloadLength = source.readShortLe().toLong()
             val headerSize = source.readShortLe().toUShort()
 
             val entryVersion = headerSizeToVersion(headerSize)
@@ -177,11 +178,17 @@ data class LogLine(
             val processInformation = ProcessInformation(pid, tid, uid)
             val time = Instant.fromEpochSeconds(sec, nSec)
 
-            val priorityByte = source.readByte()
+            // the payload is split into three parts
+            // initial priority byte -> null terminated tag -> non null terminated message
+
+            val packetBuffer = Buffer()
+            source.readFully(packetBuffer, payloadLength)
+
+            val priorityByte = packetBuffer.readByte()
             val priority = LogPriority.fromByte(priorityByte)
 
-            val tag = source.readCString()
-            val message = source.readCString()
+            val tag = packetBuffer.readCString()
+            val message = packetBuffer.readUtf8()
 
             return LogLine(
                 process = processInformation,
@@ -205,7 +212,9 @@ data class LogLine(
 
     val identifier = time.toJavaInstant()
 
-    val messageTrimmed by lazy { this.message.trim() }
+    val messageTrimmed by lazy {
+        this.message.trim { it <= ' ' }
+    }
 
     val formattedTime by lazy { this.time.toLocalDateTime(TimeZone.currentSystemDefault()) }
     val asSimpleString by lazy {

app/src/main/java/com/geode/launcher/log/LogViewModel.kt

@@ -9,7 +9,9 @@ import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import kotlinx.coroutines.yield
+import okio.Buffer
 import okio.buffer
 import okio.source
 import java.io.EOFException
@@ -61,7 +63,9 @@ class LogViewModel: ViewModel() {
             else "logcat -B -d"
 
         val logProcess = try {
-            Runtime.getRuntime().exec(logCommand)
+            withContext(Dispatchers.IO) {
+                Runtime.getRuntime().exec(logCommand)
+            }
         } catch (ioe: IOException) {
             ioe.printStackTrace()
             logLines += LogLine.showException(ioe)
@@ -71,13 +75,15 @@ class LogViewModel: ViewModel() {
             return logLines
         }
 
-        val logSource = logProcess.inputStream.source().buffer()
+        // read entire log into a buffer so no logs are added to the buffer during processing
+        val logBuffer = Buffer()
+        logProcess.inputStream.source().buffer().readAll(logBuffer)
 
         try {
             coroutineScope {
                 // this runs until the stream is exhausted
                 while (true) {
-                    val line = LogLine.fromBufferedSource(logSource)
+                    val line = LogLine.fromBufferedSource(logBuffer)
 
                     if (line.priority >= logLevel) {
                         logLines += line

app/src/main/java/com/geode/launcher/main/Components.kt

@@ -0,0 +1,89 @@
+package com.geode.launcher.main
+
+import android.content.ActivityNotFoundException
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.widget.Toast
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.sizeIn
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.AbsoluteRoundedCornerShape
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import com.geode.launcher.R
+import com.geode.launcher.utils.Constants
+
+fun onDownloadGame(context: Context) {
+    val appUrl = "https://play.google.com/store/apps/details?id=${Constants.PACKAGE_NAME}"
+    try {
+        val intent = Intent(Intent.ACTION_VIEW).apply {
+            data = Uri.parse(appUrl)
+            setPackage("com.android.vending")
+        }
+        context.startActivity(intent)
+    } catch (_: ActivityNotFoundException) {
+        Toast.makeText(context, R.string.no_activity_found, Toast.LENGTH_SHORT).show()
+    }
+}
+
+@Composable
+fun GooglePlayBadge(modifier: Modifier = Modifier) {
+    val context = LocalContext.current
+
+    Image(
+        painter = painterResource(id = R.drawable.google_play_badge),
+        contentDescription = stringResource(R.string.launcher_download_game),
+        modifier = modifier
+            .width(196.dp)
+            .clip(AbsoluteRoundedCornerShape(4.dp))
+            .clickable { onDownloadGame(context) }
+    )
+}
+
+@Composable
+fun StatusIndicator(
+    icon: @Composable () -> Unit,
+    text: @Composable () -> Unit,
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier
+) {
+    ElevatedCard(modifier = modifier, onClick = onClick) {
+        Row(modifier = Modifier.padding(8.dp)) {
+            icon()
+            Spacer(Modifier.size(8.dp))
+            text()
+        }
+    }
+}
+
+@Composable
+fun InlineDialog(headline: @Composable () -> Unit, body: @Composable () -> Unit, modifier: Modifier = Modifier) {
+    ElevatedCard(modifier = modifier) {
+        Column(modifier = Modifier.padding(18.dp).sizeIn(maxWidth = 512.dp)) {
+            Row(
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.spacedBy(8.dp),
+                modifier = Modifier.padding(bottom = 8.dp)
+            ) {
+                headline()
+            }
+
+            body()
+        }
+    }
+}

app/src/main/java/com/geode/launcher/main/ErrorComponents.kt

@@ -0,0 +1,391 @@
+package com.geode.launcher.main
+
+import android.content.ActivityNotFoundException
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.provider.DocumentsContract
+import android.widget.Toast
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Share
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.FilledTonalButton
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ModalBottomSheet
+import androidx.compose.material3.SnackbarDuration
+import androidx.compose.material3.SnackbarHostState
+import androidx.compose.material3.SnackbarResult
+import androidx.compose.material3.Text
+import androidx.compose.material3.rememberModalBottomSheetState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalClipboardManager
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.LinkAnnotation
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.TextLinkStyles
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.style.TextDecoration
+import androidx.compose.ui.text.withLink
+import androidx.compose.ui.unit.dp
+import com.geode.launcher.preferences.ApplicationLogsActivity
+import com.geode.launcher.BuildConfig
+import com.geode.launcher.R
+import com.geode.launcher.UserDirectoryProvider
+import com.geode.launcher.ui.theme.Typography
+import com.geode.launcher.utils.GamePackageUtils
+import com.geode.launcher.utils.LaunchUtils
+import com.geode.launcher.utils.PreferenceUtils
+
+data class LoadFailureInfo(
+    val title: LaunchUtils.LauncherError,
+    val description: String? = null,
+    val extendedMessage: String? = null
+)
+
+@Composable
+fun ErrorInfoBody(failureReason: LaunchUtils.LauncherError, modifier: Modifier = Modifier) {
+    val headline = when (failureReason) {
+        LaunchUtils.LauncherError.LINKER_FAILED -> stringResource(R.string.load_failed_link_error_description)
+        LaunchUtils.LauncherError.CRASHED -> stringResource(R.string.load_failed_crashed_description)
+        else -> stringResource(R.string.load_failed_generic_error_description)
+    }
+
+    val context = LocalContext.current
+    val recommendations = when (failureReason) {
+        LaunchUtils.LauncherError.LINKER_FAILED_STL -> {
+            val isDeveloper = PreferenceUtils.get(context).getBoolean(PreferenceUtils.Key.DEVELOPER_MODE)
+
+            buildList {
+                add(stringResource(R.string.load_failed_recommendation_update))
+                add(stringResource(R.string.load_failed_recommendation_report))
+
+                if (isDeveloper)
+                    add(stringResource(R.string.load_failed_recommendation_dev_stl))
+            }
+        }
+        LaunchUtils.LauncherError.LINKER_FAILED -> listOfNotNull(
+            stringResource(R.string.load_failed_recommendation_reinstall),
+            stringResource(R.string.load_failed_recommendation_update),
+        )
+        LaunchUtils.LauncherError.CRASHED -> listOf(
+            stringResource(R.string.load_failed_recommendation_safe_mode),
+            stringResource(R.string.load_failed_recommendation_report)
+        )
+        else -> listOf(
+            stringResource(R.string.load_failed_recommendation_reinstall),
+            stringResource(R.string.load_failed_recommendation_update),
+            stringResource(R.string.load_failed_recommendation_report)
+        )
+    }
+
+    Column(modifier = modifier) {
+        Text(headline)
+
+        recommendations.forEach { r ->
+            Text("\u2022\u00A0\u00A0$r")
+        }
+    }
+}
+
+@Composable
+fun ErrorInfoTitle(failureReason: LaunchUtils.LauncherError) {
+    val message = when (failureReason) {
+        LaunchUtils.LauncherError.LINKER_NEEDS_64BIT,
+        LaunchUtils.LauncherError.LINKER_NEEDS_32BIT,
+        LaunchUtils.LauncherError.LINKER_FAILED_STL,
+        LaunchUtils.LauncherError.LINKER_FAILED -> stringResource(R.string.load_failed_link_error)
+        LaunchUtils.LauncherError.GENERIC -> stringResource(R.string.load_failed_generic_error)
+        LaunchUtils.LauncherError.CRASHED -> stringResource(R.string.load_failed_crashed)
+    }
+
+    Row(
+        horizontalArrangement = Arrangement.spacedBy(10.dp),
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Icon(
+            painterResource(R.drawable.icon_error),
+            contentDescription = stringResource(R.string.launcher_error_icon_alt),
+            modifier = Modifier.size(28.dp)
+        )
+        Text(message, style = Typography.headlineMedium)
+    }
+
+}
+
+fun onShareCrash(context: Context) {
+    val lastCrash = LaunchUtils.getLastCrash(context)
+    if (lastCrash == null) {
+        Toast.makeText(context, R.string.launcher_error_export_missing, Toast.LENGTH_SHORT).show()
+        return
+    }
+
+    val baseDirectory = LaunchUtils.getBaseDirectory(context)
+
+    val providerLocation = lastCrash.toRelativeString(baseDirectory)
+    val documentsPath = "${UserDirectoryProvider.ROOT}${providerLocation}"
+
+    val uri = DocumentsContract.buildDocumentUri("${context.packageName}.user", documentsPath)
+
+    val shareIntent = Intent(Intent.ACTION_SEND).apply {
+        putExtra(Intent.EXTRA_STREAM, uri)
+        type = "application/octet-stream"
+    }
+
+    try {
+        context.startActivity(shareIntent)
+    } catch (_: ActivityNotFoundException) {
+        Toast.makeText(context, R.string.no_activity_found, Toast.LENGTH_SHORT).show()
+    }
+}
+
+fun onShowLogs(context: Context) {
+    val launchIntent = Intent(context, ApplicationLogsActivity::class.java)
+    context.startActivity(launchIntent)
+}
+
+@Composable
+fun ErrorInfoDescription(description: String, modifier: Modifier = Modifier) {
+    val context = LocalContext.current
+    val currentRelease = remember {
+        PreferenceUtils.get(context).getString(PreferenceUtils.Key.CURRENT_VERSION_TAG)
+    }
+
+    val gameVersion = remember {
+        GamePackageUtils.getUnifiedVersionName(context.packageManager)
+    }
+
+    Column(modifier = modifier) {
+        Text(
+            stringResource(R.string.launcher_error_details),
+            style = Typography.headlineSmall
+        )
+
+        Spacer(Modifier.size(8.dp))
+
+        Text(
+            description,
+            fontFamily = FontFamily.Monospace,
+            style = Typography.bodyMedium
+        )
+
+        Spacer(Modifier.size(4.dp))
+
+        Text(
+            stringResource(R.string.launcher_error_device_info,
+                Build.MODEL,
+                Build.VERSION.RELEASE,
+                currentRelease ?: "unknown",
+                gameVersion,
+                LaunchUtils.applicationArchitecture,
+                BuildConfig.VERSION_NAME
+            ),
+            style = Typography.labelMedium
+        )
+    }
+}
+
+@Composable
+@OptIn(ExperimentalLayoutApi::class)
+fun ErrorInfoActions(extraDetails: String?, modifier: Modifier = Modifier) {
+    val clipboardManager = LocalClipboardManager.current
+    val context = LocalContext.current
+
+    FlowRow(
+        modifier = modifier,
+        horizontalArrangement = Arrangement.spacedBy(
+            12.dp, alignment = Alignment.CenterHorizontally
+        )
+    ) {
+        if (extraDetails != null) {
+            Button(onClick = { onShowLogs(context) }) {
+                Icon(
+                    painterResource(R.drawable.icon_description),
+                    contentDescription = null
+                )
+                Spacer(Modifier.size(ButtonDefaults.IconSpacing))
+                Text(stringResource(R.string.launcher_error_view_logs))
+            }
+
+            FilledTonalButton(onClick = {
+                clipboardManager.setText(AnnotatedString(extraDetails))
+            }) {
+                Icon(
+                    painterResource(R.drawable.icon_content_copy),
+                    contentDescription = null
+                )
+                Spacer(Modifier.size(ButtonDefaults.IconSpacing))
+                Text(stringResource(R.string.launcher_error_copy))
+            }
+        } else {
+            Button(onClick = { onShareCrash(context) }) {
+                Icon(
+                    Icons.Filled.Share,
+                    contentDescription = null
+                )
+                Spacer(Modifier.size(ButtonDefaults.IconSpacing))
+                Text(stringResource(R.string.launcher_error_export_crash))
+            }
+
+            FilledTonalButton(onClick = { onShowLogs(context) }) {
+                Icon(
+                    painterResource(R.drawable.icon_description),
+                    contentDescription = null
+                )
+                Spacer(Modifier.size(ButtonDefaults.IconSpacing))
+                Text(stringResource(R.string.launcher_error_view_logs))
+            }
+        }
+    }
+}
+
+
+@Composable
+fun DownloadRecommendation(needsUniversal: Boolean, modifier: Modifier = Modifier) {
+    val context = LocalContext.current
+    val version = BuildConfig.VERSION_NAME
+
+    val showDownload = remember { GamePackageUtils.showDownloadBadge(context.packageManager) }
+
+    val downloadBase = "https://github.com/geode-sdk/android-launcher/releases/download/$version"
+    val legacyDownloadUrl = "$downloadBase/geode-launcher-v$version-android32.apk"
+    val universalDownloadUrl = "$downloadBase/geode-launcher-v$version.apk"
+
+    val downloadUrl = if (needsUniversal)
+        universalDownloadUrl else legacyDownloadUrl
+
+    val downloadText = if (needsUniversal)
+        stringResource(R.string.launcher_download_universal)
+    else
+        stringResource(R.string.launcher_download_32bit)
+
+    val promptTitle = stringResource(R.string.load_failed_abi_error)
+    val reinstallText = stringResource(R.string.load_failed_recommendation_reinstall)
+    val recommendationText = if (needsUniversal)
+        stringResource(R.string.load_failed_recommendation_switch_64bit_abi)
+    else
+        stringResource(R.string.load_failed_recommendation_switch_32bit_abi)
+
+    Column(
+        modifier = modifier,
+        verticalArrangement = Arrangement.spacedBy(
+            12.dp, alignment = Alignment.CenterVertically
+        )
+    ) {
+        Text(promptTitle)
+        Text("\u2022\u00A0\u00A0$reinstallText")
+
+        if (showDownload) {
+            GooglePlayBadge()
+        }
+
+        Text("\u2022\u00A0\u00A0$recommendationText")
+
+        Text(
+            buildAnnotatedString {
+                withLink(LinkAnnotation.Url(
+                    downloadUrl,
+                    TextLinkStyles(
+                        style = SpanStyle(
+                            color = MaterialTheme.colorScheme.primary,
+                            textDecoration = TextDecoration.Underline
+                        ),
+                    )
+                )) {
+                    append(downloadText)
+                }
+            }
+        )
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun ErrorInfoSheet(failureInfo: LoadFailureInfo, onDismiss: () -> Unit) {
+    val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true)
+
+    ModalBottomSheet(onDismissRequest = { onDismiss() }, sheetState = sheetState) {
+        // second container created for scroll (before padding is added)
+        Box(Modifier.verticalScroll(rememberScrollState())) {
+            Column(modifier = Modifier
+                .padding(horizontal = 24.dp)
+            ) {
+                ErrorInfoTitle(failureInfo.title)
+
+                Spacer(Modifier.size(16.dp))
+
+                if (failureInfo.title.isAbiFailure()) {
+                    DownloadRecommendation(
+                        needsUniversal = failureInfo.title == LaunchUtils.LauncherError.LINKER_NEEDS_64BIT,
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .padding(top = 8.dp, bottom = 16.dp)
+                    )
+                } else {
+                    ErrorInfoBody(failureInfo.title)
+
+                    if (failureInfo.description != null) {
+                        ErrorInfoDescription(
+                            failureInfo.description,
+                            modifier = Modifier.padding(vertical = 8.dp)
+                        )
+                    }
+
+                    ErrorInfoActions(
+                        extraDetails = failureInfo.extendedMessage ?: failureInfo.description,
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .padding(top = 8.dp, bottom = 16.dp)
+                    )
+                }
+            }
+        }
+    }
+}
+
+suspend fun showFailureSnackbar(
+    context: Context,
+    loadFailureInfo: LoadFailureInfo,
+    snackbarHostState: SnackbarHostState,
+    onActionPerformed: () -> Unit
+) {
+    val message = if (loadFailureInfo.title == LaunchUtils.LauncherError.CRASHED) {
+        context.getString(R.string.launcher_crashed)
+    } else {
+        context.getString(R.string.launcher_failed_to_load)
+    }
+
+    val res = snackbarHostState.showSnackbar(
+        message = message,
+        actionLabel = context.getString(R.string.launcher_error_more),
+        duration = SnackbarDuration.Indefinite,
+    )
+
+    when (res) {
+        SnackbarResult.ActionPerformed -> {
+            onActionPerformed()
+        }
+        SnackbarResult.Dismissed -> {}
+    }
+}

app/src/main/java/com/geode/launcher/main/LaunchComponents.kt

@@ -0,0 +1,315 @@
+package com.geode.launcher.main
+
+import android.content.Context
+import android.content.Intent
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.interaction.PressInteraction
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.RowScope
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.PlayArrow
+import androidx.compose.material.icons.filled.Settings
+import androidx.compose.material.icons.filled.Warning
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.hapticfeedback.HapticFeedbackType
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalHapticFeedback
+import androidx.compose.ui.platform.LocalViewConfiguration
+import androidx.compose.ui.res.pluralStringResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import com.geode.launcher.GeometryDashActivity
+import com.geode.launcher.R
+import com.geode.launcher.preferences.SettingsActivity
+import com.geode.launcher.ui.theme.Typography
+import com.geode.launcher.utils.Constants
+import com.geode.launcher.utils.GamePackageUtils
+import com.geode.launcher.utils.GeodeUtils
+import com.geode.launcher.utils.PreferenceUtils
+import com.geode.launcher.utils.useCountdownTimer
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.collectLatest
+
+
+@Composable
+fun UpdateWarning(inSafeMode: Boolean = false, onDismiss: () -> Unit) {
+    val context = LocalContext.current
+    val packageManager = context.packageManager
+
+    val gdVersionCode = remember { GamePackageUtils.getGameVersionCode(packageManager) }
+    val gdVersionString = remember { GamePackageUtils.getGameVersionString(packageManager) }
+
+    var lastDismissedVersion by PreferenceUtils.useLongPreference(
+        preferenceKey = PreferenceUtils.Key.DISMISSED_GJ_UPDATE
+    )
+
+    val onUnsupportedVersion = gdVersionCode < Constants.SUPPORTED_VERSION_CODE_MIN || gdVersionCode > Constants.SUPPORTED_VERSION_CODE
+    val canDismissRelease = gdVersionCode >= Constants.SUPPORTED_VERSION_CODE
+    val shouldDismiss = canDismissRelease && gdVersionCode == lastDismissedVersion
+
+    if (onUnsupportedVersion && !shouldDismiss) {
+        AlertDialog(
+            icon = {
+                Icon(
+                    Icons.Filled.Warning,
+                    contentDescription = stringResource(R.string.launcher_warning_icon_alt)
+                )
+            },
+            title = {
+                Text(stringResource(R.string.launcher_unsupported_version_title))
+            },
+            text = {
+                Text(
+                    stringResource(
+                    R.string.launcher_unsupported_version_description,
+                    gdVersionString,
+                    Constants.SUPPORTED_VERSION_STRING
+                )
+                )
+            },
+            confirmButton = {
+                TextButton(onClick = {
+                    onDismiss()
+                    lastDismissedVersion = gdVersionCode
+
+                    onLaunch(context, inSafeMode)
+                }) {
+                    Text(stringResource(R.string.message_box_accept))
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { onDismiss() }) {
+                    Text(stringResource(R.string.message_box_cancel))
+                }
+            },
+            onDismissRequest = { onDismiss() }
+        )
+    } else {
+        LaunchedEffect(gdVersionCode) {
+            onLaunch(context, inSafeMode)
+        }
+    }
+}
+
+@Composable
+fun SafeModeDialog(onDismiss: () -> Unit, onLaunch: () -> Unit) {
+    AlertDialog(
+        icon = {
+            Icon(
+                Icons.Filled.Warning,
+                contentDescription = stringResource(R.string.launcher_warning_icon_alt)
+            )
+        },
+        title = { Text(stringResource(R.string.safe_mode_enable_title)) },
+        text = { Text(stringResource(R.string.safe_mode_enable_description)) },
+        dismissButton = {
+            TextButton(onClick = onDismiss) {
+                Text(stringResource(R.string.message_box_cancel))
+            }
+        },
+        confirmButton = {
+            TextButton(onClick = onLaunch) {
+                Text(stringResource(R.string.message_box_continue))
+            }
+        },
+        onDismissRequest = onDismiss
+    )
+}
+
+fun onLaunch(context: Context, safeMode: Boolean = false) {
+    if (safeMode) {
+        GeodeUtils.setAdditionalLaunchArguments(GeodeUtils.ARGUMENT_SAFE_MODE)
+    } else {
+        GeodeUtils.clearLaunchArguments()
+    }
+
+    val launchIntent = Intent(context, GeometryDashActivity::class.java)
+    launchIntent.flags = Intent.FLAG_ACTIVITY_CLEAR_TASK or Intent.FLAG_ACTIVITY_NEW_TASK
+
+    context.startActivity(launchIntent)
+}
+
+fun onSettings(context: Context) {
+    val launchIntent = Intent(context, SettingsActivity::class.java)
+    context.startActivity(launchIntent)
+}
+
+@Composable
+fun LongPressButton(onClick: () -> Unit, onLongPress: () -> Unit, enabled: Boolean = true, modifier: Modifier = Modifier, content: @Composable RowScope.() -> Unit) {
+    // compose apis don't provide a good way of adding long press to a button
+    var isLongPress by remember { mutableStateOf(false) }
+
+    val interactionSource = remember { MutableInteractionSource() }
+    val viewConfiguration = LocalViewConfiguration.current
+    val haptics = LocalHapticFeedback.current
+
+    LaunchedEffect(interactionSource) {
+        interactionSource.interactions.collectLatest { interaction ->
+            when (interaction) {
+                is PressInteraction.Press -> {
+                    delay(viewConfiguration.longPressTimeoutMillis)
+
+                    // perform a second delay to make the action more obvious
+                    haptics.performHapticFeedback(HapticFeedbackType.LongPress)
+                    delay(viewConfiguration.longPressTimeoutMillis)
+
+                    haptics.performHapticFeedback(HapticFeedbackType.LongPress)
+
+                    isLongPress = true
+                    onLongPress()
+                }
+                is PressInteraction.Release -> {
+                    if (!isLongPress) {
+                        onClick()
+                    }
+                    isLongPress = false
+                }
+            }
+        }
+    }
+
+    Button(
+        onClick = {},
+        enabled = enabled,
+        modifier = modifier,
+        interactionSource = interactionSource,
+        content = content
+    )
+}
+
+@Composable
+fun PlayButton(
+    stopAutomaticLaunch: Boolean,
+    blockLaunch: Boolean,
+    onPlayGame: (Boolean) -> Unit
+) {
+    val context = LocalContext.current
+
+    var showSafeModeDialog by remember { mutableStateOf(false) }
+    var launchInSafeMode by remember { mutableStateOf(false) }
+
+    val shouldAutomaticallyLaunch by PreferenceUtils.useBooleanPreference(
+        preferenceKey = PreferenceUtils.Key.LOAD_AUTOMATICALLY
+    )
+
+    if (shouldAutomaticallyLaunch && !stopAutomaticLaunch && !showSafeModeDialog) {
+        val countdownTimer = useCountdownTimer(
+            time = 3000,
+            onCountdownFinish = { onPlayGame(launchInSafeMode) }
+        )
+
+        if (countdownTimer != 0L) {
+            Text(
+                pluralStringResource(
+                    R.plurals.automatically_load_countdown,
+                    countdownTimer.toInt(),
+                    countdownTimer
+                ),
+                style = Typography.bodyMedium,
+                color = MaterialTheme.colorScheme.onSecondaryContainer,
+            )
+            Spacer(Modifier.size(12.dp))
+        }
+    }
+
+    Row {
+        LongPressButton(
+            enabled = !blockLaunch,
+            onLongPress = {
+                showSafeModeDialog = true
+            },
+            onClick = {
+                onPlayGame(launchInSafeMode)
+            }
+        ) {
+            Icon(
+                Icons.Filled.PlayArrow,
+                contentDescription = context.getString(R.string.launcher_launch_icon_alt)
+            )
+            Spacer(Modifier.size(ButtonDefaults.IconSpacing))
+            Text(context.getString(R.string.launcher_launch))
+        }
+        Spacer(Modifier.size(2.dp))
+        IconButton(onClick = { onSettings(context) }) {
+            Icon(
+                Icons.Filled.Settings,
+                contentDescription = context.getString(R.string.launcher_settings_icon_alt)
+            )
+        }
+    }
+
+    if (showSafeModeDialog) {
+        SafeModeDialog(
+            onDismiss = {
+                launchInSafeMode = false
+                showSafeModeDialog = false
+            },
+            onLaunch = {
+                launchInSafeMode = true
+
+                onPlayGame(true)
+
+                showSafeModeDialog = false
+            }
+        )
+    }
+}
+
+@Composable
+fun LaunchBlockedLabel(text: String) {
+    val context = LocalContext.current
+
+    val showDownload = remember { GamePackageUtils.showDownloadBadge(context.packageManager) }
+
+    Column(horizontalAlignment = Alignment.CenterHorizontally) {
+        Text(text, textAlign = TextAlign.Center, modifier = Modifier.padding(12.dp))
+
+        if (showDownload) {
+            GooglePlayBadge()
+        }
+    }
+}
+
+@Composable
+fun UnsupportedVersionWarning(modifier: Modifier = Modifier) {
+    InlineDialog(
+        headline = {
+            Icon(
+                Icons.Default.Warning,
+                contentDescription = null,
+                modifier = Modifier.size(28.dp)
+            )
+
+            Text(
+                stringResource(R.string.launcher_unsupported_version_title),
+                style = MaterialTheme.typography.titleMedium,
+            )
+        },
+        body = {
+            Text(
+                stringResource(R.string.launcher_game_update_required),
+            )
+        },
+        modifier = modifier.padding(8.dp)
+    )
+}

app/src/main/java/com/geode/launcher/main/LaunchNotification.kt

@@ -0,0 +1,260 @@
+package com.geode.launcher.main
+
+import android.content.Context
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.MutableTransitionState
+import androidx.compose.animation.expandHorizontally
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.shrinkHorizontally
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.IntrinsicSize
+import androidx.compose.foundation.layout.displayCutoutPadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Info
+import androidx.compose.material.icons.filled.Warning
+import androidx.compose.material3.Icon
+import androidx.compose.material3.ListItem
+import androidx.compose.material3.LocalContentColor
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedCard
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import com.geode.launcher.R
+import com.geode.launcher.ui.theme.GeodeLauncherTheme
+import com.geode.launcher.ui.theme.LocalTheme
+import com.geode.launcher.ui.theme.Theme
+import com.geode.launcher.updater.ReleaseManager
+import com.geode.launcher.utils.Constants
+import com.geode.launcher.utils.GamePackageUtils
+import com.geode.launcher.utils.PreferenceUtils
+import kotlinx.coroutines.delay
+
+enum class LaunchNotificationType {
+    GEODE_UPDATED, LAUNCHER_UPDATE_AVAILABLE, UPDATE_FAILED, UNSUPPORTED_VERSION;
+}
+
+fun determineDisplayedCards(context: Context): List<LaunchNotificationType> {
+    val cards = mutableListOf<LaunchNotificationType>()
+
+    if (GamePackageUtils.getGameVersionCode(context.packageManager) < Constants.SUPPORTED_VERSION_CODE_MIN_WARNING) {
+        cards.add(LaunchNotificationType.UNSUPPORTED_VERSION)
+    }
+
+    val releaseManager = ReleaseManager.get(context)
+    val loadAutomatically = PreferenceUtils.get(context).getBoolean(PreferenceUtils.Key.LOAD_AUTOMATICALLY)
+
+    val availableUpdate = releaseManager.availableLauncherUpdate.value
+    if (loadAutomatically && availableUpdate != null) {
+        cards.add(LaunchNotificationType.LAUNCHER_UPDATE_AVAILABLE)
+    }
+
+    val releaseState = releaseManager.uiState.value
+
+    if (releaseState is ReleaseManager.ReleaseManagerState.Finished && releaseState.hasUpdated) {
+        cards.add(LaunchNotificationType.GEODE_UPDATED)
+    }
+
+    if (releaseState is ReleaseManager.ReleaseManagerState.Failure) {
+        cards.add(LaunchNotificationType.UPDATE_FAILED)
+    }
+
+    return cards
+}
+
+@Composable
+fun NotificationCardFromType(type: LaunchNotificationType) {
+    when (type) {
+        LaunchNotificationType.LAUNCHER_UPDATE_AVAILABLE -> {
+            var showInfoDialog by remember { mutableStateOf(false) }
+
+            if (showInfoDialog) {
+                LauncherUpdateInformation {
+                    showInfoDialog = false
+                }
+            }
+
+            AnimatedNotificationCard(
+                displayLength = 5000L,
+                onClick = {
+                    showInfoDialog = true
+                }
+            ) {
+                LauncherUpdateContent()
+            }
+        }
+        LaunchNotificationType.UPDATE_FAILED -> {
+            AnimatedNotificationCard {
+                UpdateFailedContent()
+            }
+        }
+        LaunchNotificationType.UNSUPPORTED_VERSION -> {
+            AnimatedNotificationCard {
+                OutdatedVersionContent()
+            }
+        }
+        else -> {}
+    }
+}
+
+@Composable
+fun LaunchNotification() {
+    val context = LocalContext.current
+
+    val themeOption by PreferenceUtils.useIntPreference(PreferenceUtils.Key.THEME)
+    val theme = Theme.fromInt(themeOption)
+
+    val backgroundOption by PreferenceUtils.useBooleanPreference(PreferenceUtils.Key.BLACK_BACKGROUND)
+
+    val cards = determineDisplayedCards(context)
+
+    CompositionLocalProvider(LocalTheme provides theme) {
+        GeodeLauncherTheme(theme = theme, blackBackground = backgroundOption) {
+            // surface is not in use, so this is unfortunately not provided
+            CompositionLocalProvider(LocalContentColor provides MaterialTheme.colorScheme.onSurface) {
+                Column(
+                    modifier = Modifier.displayCutoutPadding()
+                ) {
+                    cards.forEach {
+                        NotificationCardFromType(it)
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+fun AnimatedNotificationCard(modifier: Modifier = Modifier, visibilityDelay: Long = 0L, displayLength: Long = 3000L, onClick: (() -> Unit)? = null, contents: @Composable () -> Unit) {
+    val state = remember {
+        MutableTransitionState(false).apply {
+            targetState = visibilityDelay <= 0
+        }
+    }
+
+    LaunchedEffect(true) {
+        if (visibilityDelay > 0) {
+            delay(visibilityDelay)
+            state.targetState = true
+        }
+
+        delay(displayLength)
+        state.targetState = false
+    }
+
+    AnimatedVisibility(
+        visibleState = state,
+        enter = expandHorizontally() + fadeIn(),
+        exit = shrinkHorizontally() + fadeOut(),
+        modifier = modifier
+    ) {
+        CardView(onClick, modifier = Modifier.padding(8.dp)) {
+            contents()
+        }
+    }
+}
+
+@Composable
+fun CardView(onClick: (() -> Unit)?, modifier: Modifier = Modifier, contents: @Composable () -> Unit) {
+    // val surfaceColor = MaterialTheme.colorScheme.background.copy(alpha = 0.75f)
+
+    if (onClick != null) {
+        OutlinedCard(
+            onClick = onClick,
+            modifier = modifier
+        ) {
+            contents()
+        }
+    } else {
+        OutlinedCard(
+            modifier = modifier
+        ) {
+            contents()
+        }
+    }
+}
+
+@Composable
+fun LauncherUpdateContent(modifier: Modifier = Modifier) {
+    ListItem(
+        headlineContent = {
+            Text(text = stringResource(id = R.string.launcher_update_available))
+        },
+        supportingContent = {
+            Text(text = stringResource(id = R.string.launcher_notification_update_cta))
+        },
+        leadingContent = {
+            Icon(
+                Icons.Filled.Info,
+                contentDescription = null,
+            )
+        },
+        modifier = modifier.width(IntrinsicSize.Max)
+    )
+}
+
+@Composable
+fun UpdateNotificationContent(modifier: Modifier = Modifier) {
+    ListItem(
+        headlineContent = {
+            Text(text = stringResource(id = R.string.launcher_notification_update_success))
+        },
+        leadingContent = {
+            Icon(
+                painterResource(R.drawable.geode_monochrome),
+                contentDescription = null,
+                modifier = Modifier.size(24.dp)
+            )
+        },
+        modifier = modifier.width(IntrinsicSize.Max)
+    )
+}
+
+@Composable
+fun OutdatedVersionContent(modifier: Modifier = Modifier) {
+    ListItem(
+        headlineContent = {
+            Text(text = stringResource(id = R.string.launcher_notification_compatibility))
+        },
+        leadingContent = {
+            Icon(
+                Icons.Filled.Warning,
+                contentDescription = null,
+            )
+        },
+        supportingContent = {
+            Text(text = stringResource(id = R.string.launcher_notification_compatibility_description))
+        },
+        modifier = modifier.width(IntrinsicSize.Max)
+    )
+}
+
+@Composable
+fun UpdateFailedContent(modifier: Modifier = Modifier) {
+    ListItem(
+        headlineContent = {
+            Text(text = stringResource(id = R.string.launcher_notification_update_failed))
+        },
+        leadingContent = {
+            Icon(
+                Icons.Filled.Warning,
+                contentDescription = null,
+            )
+        },
+        modifier = modifier.width(IntrinsicSize.Max)
+    )
+}

app/src/main/java/com/geode/launcher/main/LaunchViewModel.kt

@@ -0,0 +1,228 @@
+package com.geode.launcher.main
+
+import android.app.Application
+import android.os.CountDownTimer
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+import androidx.lifecycle.viewModelScope
+import androidx.lifecycle.viewmodel.initializer
+import androidx.lifecycle.viewmodel.viewModelFactory
+import com.geode.launcher.updater.ReleaseManager
+import com.geode.launcher.utils.Constants
+import com.geode.launcher.utils.GamePackageUtils
+import com.geode.launcher.utils.LaunchUtils
+import com.geode.launcher.utils.PreferenceUtils
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.takeWhile
+import kotlinx.coroutines.launch
+
+private const val COOLDOWN_LENGTH_MS = 3000L
+
+class LaunchViewModel(private val application: Application): ViewModel() {
+    companion object {
+        val Factory: ViewModelProvider.Factory = viewModelFactory {
+            initializer {
+                val application = this[ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY] as Application
+
+                LaunchViewModel(
+                    application = application
+                )
+            }
+        }
+    }
+
+    private var readyTimerPassed = false
+    private var readyTimer: CountDownTimer? = null
+
+    private fun initReadyTimer() {
+        readyTimer = object : CountDownTimer(COOLDOWN_LENGTH_MS, 1000) {
+            override fun onTick(millisUntilFinished: Long) {
+                // no tick necessary
+            }
+
+            override fun onFinish() {
+                readyTimerPassed = true
+
+                if (_uiState.value is LaunchUIState.Working) {
+                    viewModelScope.launch {
+                        preReadyCheck()
+                    }
+                }
+            }
+        }.start()
+    }
+
+    enum class LaunchCancelReason {
+        MANUAL, AUTOMATIC, LAST_LAUNCH_CRASHED, GEODE_NOT_FOUND, GAME_MISSING, GAME_OUTDATED;
+
+        fun allowsRetry() = when (this) {
+            MANUAL,
+            AUTOMATIC,
+            LAST_LAUNCH_CRASHED,
+            GEODE_NOT_FOUND -> true
+            GAME_MISSING,
+            GAME_OUTDATED -> false
+        }
+
+        fun isGameInstallIssue() = when (this) {
+            GAME_OUTDATED,
+            GAME_MISSING -> true
+            else -> false
+        }
+    }
+
+    sealed class LaunchUIState {
+        data object Initial : LaunchUIState()
+        data object UpdateCheck : LaunchUIState()
+        data class Updating(val downloaded: Long, val outOf: Long?) : LaunchUIState()
+        data class Cancelled(val reason: LaunchCancelReason, val inProgress: Boolean = false) : LaunchUIState()
+        data object Working : LaunchUIState()
+        data object Ready : LaunchUIState()
+    }
+
+    private val _uiState = MutableStateFlow<LaunchUIState>(LaunchUIState.Initial)
+    val uiState = _uiState.asStateFlow()
+
+    val nextLauncherUpdate = ReleaseManager.get(application).availableLauncherUpdate
+
+    var loadFailure: LoadFailureInfo? = null
+    private var hasCheckedForUpdates = false
+    private var isCancelling = false
+    private var hasManuallyStarted = false
+
+    private suspend fun determineUpdateStatus() {
+        ReleaseManager.get(application).uiState.takeWhile {
+            it is ReleaseManager.ReleaseManagerState.InUpdateCheck || it is ReleaseManager.ReleaseManagerState.InDownload
+        }.map { when (it) {
+                is ReleaseManager.ReleaseManagerState.InUpdateCheck -> LaunchUIState.UpdateCheck
+                is ReleaseManager.ReleaseManagerState.InDownload -> LaunchUIState.Updating(it.downloaded, it.outOf)
+                else -> LaunchUIState.UpdateCheck
+            }
+        }.collect {
+            _uiState.emit(it)
+        }
+
+        // flow terminates once update check is finished
+        hasCheckedForUpdates = true
+        preReadyCheck()
+    }
+
+    fun currentCrashInfo(): LoadFailureInfo? {
+        val currentState = _uiState.value
+        if (currentState is LaunchUIState.Cancelled && currentState.reason == LaunchCancelReason.LAST_LAUNCH_CRASHED) {
+            return loadFailure
+        }
+
+        return null
+    }
+
+    fun clearCrashInfo() {
+        val currentState = _uiState.value
+        if (currentState is LaunchUIState.Cancelled && currentState.reason == LaunchCancelReason.LAST_LAUNCH_CRASHED) {
+            loadFailure = null
+        }
+    }
+
+    private suspend fun preReadyCheck() {
+        if (isCancelling) {
+            // don't let the game start if cancelled
+            return
+        }
+
+        val packageManager = application.packageManager
+
+        if (!GamePackageUtils.isGameInstalled(packageManager)) {
+            return _uiState.emit(LaunchUIState.Cancelled(LaunchCancelReason.GAME_MISSING))
+        }
+
+        if (ReleaseManager.get(application).isInUpdate) {
+            viewModelScope.launch {
+                determineUpdateStatus()
+            }
+            return
+        }
+
+        if (loadFailure != null) {
+            // last launch crashed, so cancel
+            return _uiState.emit(LaunchUIState.Cancelled(LaunchCancelReason.LAST_LAUNCH_CRASHED))
+        }
+
+        if (GamePackageUtils.getGameVersionCode(packageManager) < Constants.SUPPORTED_VERSION_CODE_MIN) {
+            return _uiState.emit(LaunchUIState.Cancelled(LaunchCancelReason.GAME_OUTDATED))
+        }
+
+        if (!LaunchUtils.isGeodeInstalled(application)) {
+            return _uiState.emit(LaunchUIState.Cancelled(LaunchCancelReason.GEODE_NOT_FOUND))
+        }
+
+        val loadAutomatically = PreferenceUtils.get(application).getBoolean(PreferenceUtils.Key.LOAD_AUTOMATICALLY)
+        if (!loadAutomatically && !hasManuallyStarted) {
+            return cancelLaunch(true)
+        }
+
+        if (!readyTimerPassed && !hasManuallyStarted) {
+            return _uiState.emit(LaunchUIState.Working)
+        }
+
+        _uiState.emit(LaunchUIState.Ready)
+    }
+
+    suspend fun beginLaunchFlow(isRestart: Boolean = false) {
+        if (isRestart) {
+            hasManuallyStarted = true
+        }
+
+        if (_uiState.value !is LaunchUIState.Initial && _uiState.value !is LaunchUIState.Cancelled) {
+            return
+        }
+
+        if (_uiState.value is LaunchUIState.Cancelled && !isRestart) {
+            return
+        }
+
+        isCancelling = false
+
+        if (!GamePackageUtils.isGameInstalled(application.packageManager)) {
+            return _uiState.emit(LaunchUIState.Cancelled(LaunchCancelReason.GAME_MISSING))
+        }
+
+        if (readyTimer == null) {
+            initReadyTimer()
+        }
+
+        val hasGeode = LaunchUtils.isGeodeInstalled(application)
+        val shouldUpdate = PreferenceUtils.get(application).getBoolean(PreferenceUtils.Key.UPDATE_AUTOMATICALLY)
+        if ((shouldUpdate && !hasCheckedForUpdates) || !hasGeode) {
+            ReleaseManager.get(application).checkForUpdates(false)
+        }
+
+        preReadyCheck()
+    }
+
+    suspend fun cancelLaunch(isAutomatic: Boolean = false) {
+        // no need to double cancel
+        if (_uiState.value is LaunchUIState.Cancelled) {
+            return
+        }
+
+        val reason = if (isAutomatic) LaunchCancelReason.AUTOMATIC else LaunchCancelReason.MANUAL
+
+        isCancelling = true
+        _uiState.emit(LaunchUIState.Cancelled(reason, true))
+
+        val releaseManager = ReleaseManager.get(application)
+        if (releaseManager.isInUpdate) {
+            releaseManager.cancelUpdate()
+        }
+
+        _uiState.emit(LaunchUIState.Cancelled(reason, false))
+    }
+
+    override fun onCleared() {
+        super.onCleared()
+
+        readyTimer?.cancel()
+    }
+}

app/src/main/java/com/geode/launcher/main/UpdateComponents.kt

@@ -0,0 +1,427 @@
+package com.geode.launcher.main
+
+import android.content.ActivityNotFoundException
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.provider.DocumentsContract
+import android.text.format.Formatter
+import android.widget.Toast
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Refresh
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.LinearProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ModalBottomSheet
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.rememberModalBottomSheetState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalUriHandler
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.style.TextDecoration
+import androidx.compose.ui.unit.dp
+import com.geode.launcher.R
+import com.geode.launcher.UserDirectoryProvider
+import com.geode.launcher.ui.theme.Typography
+import com.geode.launcher.updater.ReleaseManager
+import com.geode.launcher.updater.ReleaseViewModel
+import com.geode.launcher.utils.LaunchUtils
+import com.geode.launcher.utils.PreferenceUtils
+import com.mikepenz.markdown.compose.LocalBulletListHandler
+import com.mikepenz.markdown.m3.Markdown
+import com.mikepenz.markdown.m3.markdownColor
+import com.mikepenz.markdown.m3.markdownTypography
+import kotlinx.datetime.toJavaInstant
+import java.io.File
+import java.net.ConnectException
+import java.net.UnknownHostException
+import java.text.DateFormat
+import java.util.Date
+
+fun clearDownloadedApks(context: Context) {
+    // technically we should be using the activity results but it was too inconsistent for my liking
+    val preferenceUtils = PreferenceUtils.get(context)
+    val performCleanup = preferenceUtils.getBoolean(PreferenceUtils.Key.CLEANUP_APKS)
+    if (!performCleanup) {
+        return
+    }
+
+    val baseDirectory = LaunchUtils.getBaseDirectory(context)
+
+    baseDirectory.listFiles {
+        // only select apk files
+            _, name -> name.lowercase().endsWith(".apk")
+    }?.forEach {
+        it.delete()
+    }
+
+    preferenceUtils.setBoolean(PreferenceUtils.Key.CLEANUP_APKS, false)
+}
+
+fun generateInstallIntent(uri: Uri): Intent {
+    // maybe one day i'll rewrite this to use packageinstaller. not today
+    return Intent(Intent.ACTION_INSTALL_PACKAGE).apply {
+        setDataAndType(uri, "application/vnd.android.package-archive")
+        addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+    }
+}
+
+fun installLauncherUpdate(context: Context) {
+    val nextUpdate = ReleaseManager.get(context).availableLauncherUpdate.value
+    val launcherDownload = nextUpdate?.getDownload()
+
+    if (launcherDownload != null) {
+        val outputFile = launcherDownload.filename
+        val baseDirectory = LaunchUtils.getBaseDirectory(context)
+
+        val outputPathFile = File(baseDirectory, outputFile)
+        if (!outputPathFile.exists()) {
+            return
+        }
+
+        val outputPath = "${UserDirectoryProvider.ROOT}${outputFile}"
+
+        val uri = DocumentsContract.buildDocumentUri("${context.packageName}.user", outputPath)
+
+        PreferenceUtils.get(context).setBoolean(PreferenceUtils.Key.CLEANUP_APKS, true)
+
+        try {
+            val intent = generateInstallIntent(uri)
+            context.startActivity(intent)
+        } catch (_: ActivityNotFoundException) {
+            // if it fails to install, just open it in the browser
+            try {
+                val downloadUrl = launcherDownload.url
+                val downloadIntent = Intent(Intent.ACTION_VIEW).apply {
+                    data = Uri.parse(downloadUrl)
+                }
+
+                context.startActivity(downloadIntent)
+            } catch (_: ActivityNotFoundException) {
+                Toast.makeText(context, context.getString(R.string.no_activity_found), Toast.LENGTH_SHORT).show()
+            }
+        }
+    } else {
+        Toast.makeText(context, context.getString(R.string.release_fetch_no_releases), Toast.LENGTH_SHORT).show()
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun LauncherUpdateInformation(onDismiss: () -> Unit) {
+    val context = LocalContext.current
+
+    val nextRelease = remember { ReleaseManager.get(context).availableLauncherUpdate.value }
+    val sheetState = rememberModalBottomSheetState()
+
+    if (nextRelease != null) {
+        ModalBottomSheet(onDismissRequest = { onDismiss() }, sheetState = sheetState) {
+            Box(Modifier.verticalScroll(rememberScrollState())) {
+                Column(modifier = Modifier.padding(horizontal = 24.dp)) {
+                    Text(
+                        stringResource(R.string.launcher_update_name, nextRelease.release.tagName),
+                        style = Typography.headlineSmall,
+                    )
+
+                    val releasedTime = remember {
+                        DateFormat.getDateInstance().format(
+                            Date.from(nextRelease.release.publishedAt.toJavaInstant())
+                        )
+                    }
+
+                    Text(
+                        stringResource(R.string.launcher_update_released, "$releasedTime"),
+                        style = Typography.labelLarge
+                    )
+
+                    Row(modifier = Modifier.padding(vertical = 12.dp)) {
+                        Button(
+                            onClick = { installLauncherUpdate(context) },
+                        ) {
+                            Icon(painterResource(R.drawable.icon_download), contentDescription = null)
+                            Spacer(Modifier.size(ButtonDefaults.IconSpacing))
+                            Text(stringResource(R.string.launcher_install))
+                        }
+
+                        val uriHandler = LocalUriHandler.current
+
+                        IconButton(onClick = { uriHandler.openUri(nextRelease.release.htmlUrl) }) {
+                            Icon(
+                                painterResource(R.drawable.xps_icon),
+                                stringResource(R.string.launcher_update_external_link)
+                            )
+                        }
+
+                    }
+
+                    if (nextRelease.release.body != null) {
+                        HorizontalDivider(modifier = Modifier.padding(vertical = 8.dp))
+
+                        Text(
+                            stringResource(R.string.launcher_update_changelog),
+                            style = Typography.titleLarge
+                        )
+
+                        CompositionLocalProvider(LocalBulletListHandler provides { _, _, _ -> "•  " }) {
+                            Markdown(
+                                content = nextRelease.release.body.replace("\r", ""),
+                                colors = markdownColor(
+                                    linkText = MaterialTheme.colorScheme.primary
+                                ),
+                                typography = markdownTypography(
+                                    link = MaterialTheme.typography.bodyLarge.copy(
+                                        textDecoration = TextDecoration.Underline
+                                    )
+                                ),
+                            )
+                        }
+                    }
+
+                    Spacer(modifier = Modifier.size(4.dp))
+                }
+            }
+        }
+    }
+}
+
+@Composable
+fun LauncherUpdateIndicator(modifier: Modifier = Modifier) {
+    val context = LocalContext.current
+
+    var showInfoDialog by remember { mutableStateOf(false) }
+
+    if (showInfoDialog) {
+        LauncherUpdateInformation {
+            showInfoDialog = false
+        }
+    }
+
+    ElevatedCard(modifier) {
+        Column(
+            // buttons add enough padding already, lower to compensate
+            modifier = Modifier.padding(
+                top = 20.dp,
+                start = 12.dp,
+                end = 12.dp,
+                bottom = 8.dp
+            ),
+            verticalArrangement = Arrangement.spacedBy(12.dp),
+        ) {
+            Text(
+                stringResource(R.string.launcher_update_available),
+                modifier = Modifier.padding(horizontal = 10.dp)
+            )
+
+            Row(modifier = Modifier.align(Alignment.End)) {
+                TextButton(
+                    onClick = { showInfoDialog = true },
+                ) {
+                    Text(stringResource(R.string.launcher_update_view))
+                }
+
+                TextButton(
+                    onClick = { installLauncherUpdate(context) },
+                ) {
+                    Text(stringResource(R.string.launcher_install))
+                }
+            }
+        }
+    }
+}
+
+@Composable
+fun UpdateProgressIndicator(
+    message: String,
+    releaseViewModel: ReleaseViewModel,
+    modifier: Modifier = Modifier,
+    progress: (() -> Float)? = null
+) {
+    Column(
+        verticalArrangement = Arrangement.Center,
+        horizontalAlignment = Alignment.Start,
+        modifier = modifier
+    ) {
+        Text(message, style = MaterialTheme.typography.labelMedium)
+
+        Spacer(modifier = Modifier.padding(4.dp))
+
+        if (progress == null) {
+            LinearProgressIndicator()
+        } else {
+            LinearProgressIndicator(progress = progress)
+        }
+
+        TextButton(
+            onClick = {
+                releaseViewModel.cancelUpdate()
+            },
+            modifier = Modifier.offset((-12).dp)
+        ) {
+            Text(stringResource(R.string.release_fetch_button_cancel))
+        }
+    }
+}
+
+@Composable
+fun UpdateMessageIndicator(
+    message: String,
+    releaseViewModel: ReleaseViewModel,
+    modifier: Modifier = Modifier,
+    allowRetry: Boolean = false
+) {
+    Column(
+        horizontalAlignment = Alignment.CenterHorizontally,
+        modifier = modifier
+    ) {
+        Text(
+            message,
+            textAlign = TextAlign.Center,
+        )
+
+        Spacer(modifier = Modifier.padding(4.dp))
+
+        if (allowRetry) {
+            OutlinedButton(
+                onClick = {
+                    releaseViewModel.runReleaseCheck(true)
+                },
+            ) {
+                Icon(
+                    Icons.Filled.Refresh,
+                    contentDescription = stringResource(R.string.launcher_retry_icon_alt)
+                )
+                Spacer(Modifier.size(ButtonDefaults.IconSpacing))
+                Text(stringResource(R.string.release_fetch_button_retry))
+            }
+        }
+    }
+}
+
+@Composable
+fun UpdateCard(releaseViewModel: ReleaseViewModel, modifier: Modifier = Modifier) {
+    val context = LocalContext.current
+
+    val releaseState by releaseViewModel.uiState.collectAsState()
+
+    when (val state = releaseState) {
+        is ReleaseViewModel.ReleaseUIState.Failure -> {
+            val message = when (state.exception) {
+                is UnknownHostException, is ConnectException ->
+                    stringResource(R.string.release_fetch_no_internet)
+                is ReleaseManager.UpdateException -> {
+                    when (state.exception.reason) {
+                        ReleaseManager.UpdateException.Reason.EXTERNAL_FILE_IN_USE -> stringResource(
+                            R.string.release_fetch_manual_check_required
+                        )
+                        else -> null
+                    }
+                }
+                else -> null
+            }
+
+            UpdateMessageIndicator(
+                stringResource(
+                    R.string.release_fetch_failed,
+                    message ?: stringResource(R.string.release_fetch_try_later)
+                ),
+                modifier = modifier,
+                allowRetry = true,
+                releaseViewModel = releaseViewModel
+            )
+        }
+        is ReleaseViewModel.ReleaseUIState.InDownload -> {
+            val downloaded = remember(state.downloaded) {
+                Formatter.formatShortFileSize(context, state.downloaded)
+            }
+
+            val outOf = remember(state.outOf) {
+                state.outOf?.run {
+                    Formatter.formatShortFileSize(context, this)
+                }
+            }
+
+            UpdateProgressIndicator(
+                stringResource(
+                    R.string.release_fetch_downloading,
+                    downloaded,
+                    outOf ?: "…"
+                ),
+                modifier = modifier,
+                releaseViewModel = releaseViewModel,
+                progress = {
+                    val progress = state.downloaded / state.outOf!!.toDouble()
+                    progress.toFloat()
+                }.takeIf { state.outOf != null }
+            )
+        }
+        is ReleaseViewModel.ReleaseUIState.InUpdateCheck -> {
+            UpdateProgressIndicator(
+                stringResource(R.string.release_fetch_in_progress),
+                modifier = modifier,
+                releaseViewModel = releaseViewModel
+            )
+        }
+        is ReleaseViewModel.ReleaseUIState.Finished -> {
+            if (state.hasUpdated) {
+                UpdateMessageIndicator(
+                    stringResource(R.string.release_fetch_success),
+                    modifier = modifier,
+                    releaseViewModel = releaseViewModel
+                )
+            }
+        }
+        is ReleaseViewModel.ReleaseUIState.Cancelled -> {
+            if (state.isCancelling) {
+                UpdateProgressIndicator(
+                    stringResource(R.string.release_fetch_cancelling),
+                    modifier = modifier,
+                    releaseViewModel = releaseViewModel
+                )
+            } else {
+                UpdateMessageIndicator(
+                    stringResource(R.string.release_fetch_cancelled),
+                    modifier = modifier,
+                    allowRetry = true,
+                    releaseViewModel = releaseViewModel
+                )
+            }
+        }
+    }
+
+    val nextUpdate by releaseViewModel.nextLauncherUpdate.collectAsState()
+
+    if (!releaseViewModel.isInUpdate && nextUpdate != null) {
+        LauncherUpdateIndicator(
+            modifier = modifier
+        )
+    }
+}

app/src/main/java/com/geode/launcher/preferences/ApplicationLogsActivity.kt

@@ -1,10 +1,6 @@
-package com.geode.launcher
+package com.geode.launcher.preferences
 
-import android.content.ClipData
-import android.content.ClipboardManager
-import android.content.Context
 import android.content.Intent
-import android.os.Build
 import android.os.Bundle
 import android.widget.Toast
 import androidx.activity.ComponentActivity
@@ -66,6 +62,7 @@ import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.lifecycle.viewmodel.compose.viewModel
+import com.geode.launcher.R
 import com.geode.launcher.log.LogLine
 import com.geode.launcher.log.LogPriority
 import com.geode.launcher.log.LogViewModel
@@ -138,12 +135,14 @@ fun SelectLogLevelDialog(
         onDismissRequest = onDismissRequest,
         onSelect = { onSelect(it) },
         initialValue = initialValue,
-        toLabel = {
-            // i'm lazy
-            it.name.lowercase().replaceFirstChar { c -> c.uppercaseChar() }
-        },
-        optionsCount = LogPriority.FATAL downTo LogPriority.VERBOSE
-    )
+    ) {
+        (LogPriority.VERBOSE..LogPriority.FATAL).reversed().forEach {
+            SelectOption(
+                name = it.name.lowercase().replaceFirstChar { c -> c.uppercaseChar() },
+                value = it
+            )
+        }
+    }
 }
 
 @Composable

app/src/main/java/com/geode/launcher/preferences/DeveloperSettingsActivity.kt

@@ -0,0 +1,185 @@
+package com.geode.launcher.preferences
+
+import android.os.Build
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.OnBackPressedDispatcher
+import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.filled.Info
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import com.geode.launcher.R
+import com.geode.launcher.ui.theme.GeodeLauncherTheme
+import com.geode.launcher.ui.theme.LocalTheme
+import com.geode.launcher.ui.theme.Theme
+import com.geode.launcher.utils.LabelledText
+import com.geode.launcher.utils.PreferenceUtils
+
+class DeveloperSettingsActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        enableEdgeToEdge()
+
+        super.onCreate(savedInstanceState)
+        setContent {
+            val themeOption by PreferenceUtils.useIntPreference(PreferenceUtils.Key.THEME)
+            val theme = Theme.fromInt(themeOption)
+
+            val backgroundOption by PreferenceUtils.useBooleanPreference(PreferenceUtils.Key.BLACK_BACKGROUND)
+
+            CompositionLocalProvider(LocalTheme provides theme) {
+                GeodeLauncherTheme(theme = theme, blackBackground = backgroundOption) {
+                    Surface(
+                        modifier = Modifier.fillMaxSize(),
+                        color = MaterialTheme.colorScheme.background
+                    ) {
+                        DeveloperSettingsScreen(onBackPressedDispatcher)
+                    }
+                }
+            }
+        }
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun DeveloperSettingsScreen(onBackPressedDispatcher: OnBackPressedDispatcher?) {
+    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior()
+
+    Scaffold(
+        modifier = Modifier.nestedScroll(scrollBehavior.nestedScrollConnection),
+        topBar = {
+            Column {
+                TopAppBar(
+                    navigationIcon = {
+                        IconButton(onClick = { onBackPressedDispatcher?.onBackPressed() }) {
+                            Icon(
+                                imageVector = Icons.AutoMirrored.Filled.ArrowBack,
+                                contentDescription = stringResource(R.string.back_icon_alt)
+                            )
+                        }
+                    },
+                    title = {
+                        Text(
+                            stringResource(R.string.title_activity_developer_settings),
+                            maxLines = 1,
+                            overflow = TextOverflow.Ellipsis
+                        )
+                    },
+                    scrollBehavior = scrollBehavior,
+                )
+            }
+        }
+    ) { innerPadding ->
+        Column(
+            Modifier
+                .padding(innerPadding)
+                .fillMaxWidth()
+                .verticalScroll(rememberScrollState()),
+            verticalArrangement = Arrangement.spacedBy(8.dp)
+        ) {
+
+            val developerMode by PreferenceUtils.useBooleanPreference(PreferenceUtils.Key.DEVELOPER_MODE)
+
+            SettingsCard(
+                title = stringResource(R.string.preference_developer_mode),
+                preferenceKey = PreferenceUtils.Key.DEVELOPER_MODE,
+            )
+
+            InlineText(
+                stringResource(R.string.preference_developer_mode_about)
+            )
+            
+            HorizontalDivider()
+
+            if (developerMode) {
+                OptionsGroup(title = stringResource(R.string.preference_category_gameplay)) {
+                    SettingsStringCard(
+                        title = stringResource(R.string.preference_launch_arguments_name),
+                        dialogTitle = stringResource(R.string.preference_launch_arguments_set_title),
+                        preferenceKey = PreferenceUtils.Key.LAUNCH_ARGUMENTS,
+                        filterInput = { it.filter { c ->
+                            // if only there was a better way to define this!
+                            "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*(){}<>[]?:;'\"~`-_+=\\| ".contains(c)
+                        }}
+                    )
+
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                        SettingsCard(
+                            title = stringResource(R.string.preference_force_hrr),
+                            preferenceKey = PreferenceUtils.Key.FORCE_HRR,
+                        )
+                    }
+                    /*
+                    SettingsCard(
+                        title = stringResource(R.string.preference_override_exceptions_name),
+                        description = stringResource(R.string.preference_override_exceptions_description),
+                        preferenceKey = PreferenceUtils.Key.CUSTOM_SYMBOL_LIST
+                    )
+                    */
+                }
+
+                OptionsGroup(title = stringResource(R.string.preference_category_updater)) {
+                    SettingsSelectCard(
+                        title = stringResource(R.string.preference_release_channel_tag_name),
+                        dialogTitle = stringResource(R.string.preference_release_channel_select),
+                        preferenceKey = PreferenceUtils.Key.RELEASE_CHANNEL_TAG,
+                        options = linkedMapOf(
+                            0 to stringResource(R.string.preference_release_channel_stable),
+                            1 to stringResource(R.string.preference_release_channel_beta),
+                            2 to stringResource(R.string.preference_release_channel_nightly),
+                        )
+                    )
+
+                    ElevatedCard(modifier = Modifier.padding(horizontal = 16.dp, vertical = 4.dp)) {
+                        LabelledText(
+                            label = stringResource(R.string.preference_developer_update_notice),
+                            icon = {
+                                Icon(Icons.Filled.Info, null)
+                            },
+                            modifier = Modifier.padding(8.dp)
+                        )
+                    }
+                }
+
+                OptionsGroup(title = stringResource(R.string.preference_category_testing)) {
+                    SettingsCard(
+                        title = stringResource(R.string.preference_enable_redesign),
+                        preferenceKey = PreferenceUtils.Key.ENABLE_REDESIGN,
+                    )
+                }
+
+                OptionsGroup(title = stringResource(R.string.preference_profiles)) {
+                    ProfileCreateCard()
+                    ProfileSelectCard()
+                }
+            }
+        }
+    }
+}

app/src/main/java/com/geode/launcher/preferences/SettingsActivity.kt

@@ -1,4 +1,4 @@
-package com.geode.launcher
+package com.geode.launcher.preferences
 
 import android.app.UiModeManager
 import android.content.ActivityNotFoundException
@@ -9,6 +9,7 @@ import android.content.Intent
 import android.os.Build
 import android.os.Bundle
 import android.provider.DocumentsContract
+import android.view.WindowManager
 import android.widget.Toast
 import androidx.activity.ComponentActivity
 import androidx.activity.OnBackPressedDispatcher
@@ -35,22 +36,30 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.platform.LocalClipboardManager
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.lifecycle.viewmodel.compose.viewModel
+import com.geode.launcher.BuildConfig
+import com.geode.launcher.R
+import com.geode.launcher.UserDirectoryProvider
 import com.geode.launcher.updater.ReleaseViewModel
 import com.geode.launcher.ui.theme.GeodeLauncherTheme
 import com.geode.launcher.ui.theme.LocalTheme
 import com.geode.launcher.ui.theme.Theme
-import com.geode.launcher.ui.theme.Typography
+import com.geode.launcher.utils.Constants
+import com.geode.launcher.utils.GamePackageUtils
 import com.geode.launcher.utils.LaunchUtils
 import com.geode.launcher.utils.PreferenceUtils
 import java.net.ConnectException
 import java.net.UnknownHostException
+import kotlin.math.roundToInt
 
 class SettingsActivity : ComponentActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
@@ -143,11 +152,16 @@ fun UpdateIndicator(
         is ReleaseViewModel.ReleaseUIState.InDownload -> {
             // is this the ideal design? idk
             enablePopup = true
-            val progress = updateStatus.downloaded / updateStatus.outOf.toDouble()
-
-            CircularProgressIndicator(
-                progress = { progress.toFloat() },
-            )
+            if (updateStatus.outOf != null) {
+                CircularProgressIndicator(
+                    progress = {
+                        val progress = updateStatus.downloaded / updateStatus.outOf.toDouble()
+                        progress.toFloat()
+                    },
+                )
+            } else {
+                CircularProgressIndicator()
+            }
         }
         else -> {}
     }
@@ -174,9 +188,16 @@ fun UpdateIndicator(
                         context.getString(R.string.preference_check_for_updates_success)
                     )
                 } else {
-                    snackbarHostState.showSnackbar(
-                        context.getString(R.string.preference_check_for_updates_none_found)
-                    )
+                    val gameVersion = GamePackageUtils.getGameVersionCodeOrNull(context.packageManager)
+                    if (gameVersion != null && gameVersion < Constants.SUPPORTED_VERSION_CODE) {
+                        snackbarHostState.showSnackbar(
+                            context.getString(R.string.launcher_game_update_required_short)
+                        )
+                    } else {
+                        snackbarHostState.showSnackbar(
+                            context.getString(R.string.preference_check_for_updates_none_found)
+                        )
+                    }
                 }
             }
             else -> {}
@@ -184,24 +205,6 @@ fun UpdateIndicator(
     }
 }
 
-@Composable
-fun themeToKey(theme: Int): String {
-    return when (theme) {
-        1 -> stringResource(R.string.preference_theme_light)
-        2 -> stringResource(R.string.preference_theme_dark)
-        else -> stringResource(R.string.preference_theme_default)
-    }
-}
-
-@Composable
-fun displayOptionToKey(option: Int): String {
-    return when (option) {
-        1 -> stringResource(R.string.preference_display_mode_legacy)
-        2 -> stringResource(R.string.preference_display_mode_fullscreen)
-        else -> stringResource(R.string.preference_display_mode_default)
-    }
-}
-
 fun updateTheme(context: Context, theme: Int) {
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
         val uiModeManager = context.getSystemService(Context.UI_MODE_SERVICE) as UiModeManager
@@ -228,6 +231,11 @@ fun onOpenLogs(context: Context) {
     context.startActivity(launchIntent)
 }
 
+fun onOpenDeveloperOptions(context: Context) {
+    val launchIntent = Intent(context, DeveloperSettingsActivity::class.java)
+    context.startActivity(launchIntent)
+}
+
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun SettingsScreen(
@@ -297,15 +305,25 @@ fun SettingsScreen(
                     SettingsSelectCard(
                         title = stringResource(R.string.preference_theme_name),
                         dialogTitle = stringResource(R.string.preference_theme_select),
-                        maxVal = 2,
                         preferenceKey = PreferenceUtils.Key.THEME,
-                        toLabel = { themeToKey(it) },
+                        options = linkedMapOf(
+                            0 to stringResource(R.string.preference_theme_default),
+                            1 to stringResource(R.string.preference_theme_light),
+                            2 to stringResource(R.string.preference_theme_dark),
+                        ),
                         extraSelectBehavior = { updateTheme(context, it) }
                     )
                     SettingsCard(
                         title = stringResource(R.string.preference_black_background_name),
                         preferenceKey = PreferenceUtils.Key.BLACK_BACKGROUND
                     )
+                    OptionsButton(
+                        title = stringResource(R.string.preferences_open_file_manager),
+                        onClick = { onOpenFileManager(context) }
+                    )
+                }
+
+                OptionsGroup(stringResource(R.string.preference_category_gameplay)) {
                     SettingsCard(
                         title = context.getString(R.string.preference_load_automatically_name),
                         description = context.getString(R.string.preference_load_automatically_description),
@@ -314,14 +332,65 @@ fun SettingsScreen(
                     SettingsSelectCard(
                         title = stringResource(R.string.preference_display_mode_name),
                         dialogTitle = stringResource(R.string.preference_display_mode_select),
-                        // necessary api doesn't exist on older versions of android
-                        maxVal = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) 2 else 1,
                         preferenceKey = PreferenceUtils.Key.DISPLAY_MODE,
-                        toLabel = { displayOptionToKey(it) }
+                        options = buildMap {
+                            put(0, stringResource(R.string.preference_display_mode_default))
+                            put(1, stringResource(R.string.preference_display_mode_legacy))
+
+                            // necessary api doesn't exist on older versions of android
+                            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                                put(2, stringResource(R.string.preference_display_mode_fullscreen))
+                            }
+                        }
                     )
-                    OptionsButton(
-                        title = stringResource(R.string.preferences_open_file_manager),
-                        onClick = { onOpenFileManager(context) }
+                    val currentDisplayMode by PreferenceUtils.useIntPreference(PreferenceUtils.Key.DISPLAY_MODE)
+
+                    if (currentDisplayMode == 1) {
+                        SettingsStringSelectCard(
+                            title = stringResource(R.string.preference_custom_aspect_ratio_name),
+                            description = stringResource(R.string.preference_custom_aspect_ratio_description),
+                            dialogTitle = stringResource(R.string.preference_custom_aspect_ratio_select),
+                            preferenceKey = PreferenceUtils.Key.CUSTOM_ASPECT_RATIO,
+                            options = linkedMapOf(
+                                "16_9" to stringResource(R.string.preference_custom_aspect_ratio_16x9),
+                                "16_10" to stringResource(R.string.preference_custom_aspect_ratio_16x10),
+                                "4_3" to stringResource(R.string.preference_custom_aspect_ratio_4x3),
+                                "1_1" to stringResource(R.string.preference_custom_aspect_ratio_1x1),
+                            )
+                        )
+                    }
+
+                    SettingsRangeCard(
+                        title = stringResource(R.string.preference_screen_zoom_name),
+                        description = stringResource(R.string.preference_screen_zoom_description),
+                        dialogTitle = stringResource(R.string.preference_screen_zoom_select),
+                        preferenceKey = PreferenceUtils.Key.SCREEN_ZOOM,
+                        labelSuffix = "x",
+                        range = 25..100,
+                        scale = 100,
+                        step = 5,
+                    ) {
+                        SettingsCard(
+                            title = context.getString(R.string.preference_screen_zoom_fit_name),
+                            preferenceKey = PreferenceUtils.Key.SCREEN_ZOOM_FIT,
+                            asCard = false
+                        )
+                    }
+
+                    val maxFrameRate = remember {
+                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                            context.display.supportedModes.maxOf { it.refreshRate }
+                        } else {
+                            @Suppress("DEPRECATION")
+                            (context.getSystemService(Context.WINDOW_SERVICE) as WindowManager).defaultDisplay.refreshRate
+                        }.roundToInt()
+                    }
+
+                    SettingsFPSCard(
+                        title = stringResource(R.string.preference_limit_framerate_name),
+                        dialogTitle = stringResource(R.string.preference_limit_framerate_select),
+                        preferenceKey = PreferenceUtils.Key.LIMIT_FRAME_RATE,
+                        maxFrameRate = maxFrameRate
                     )
                 }
 
@@ -330,10 +399,6 @@ fun SettingsScreen(
                         title = context.getString(R.string.preference_update_automatically_name),
                         preferenceKey = PreferenceUtils.Key.UPDATE_AUTOMATICALLY,
                     )
-                    SettingsCard(
-                        title = context.getString(R.string.preference_release_channel_name),
-                        preferenceKey = PreferenceUtils.Key.RELEASE_CHANNEL,
-                    )
                     OptionsCard(
                         title = {
                             OptionsTitle(
@@ -361,31 +426,94 @@ fun SettingsScreen(
                 }
 
                 OptionsGroup(stringResource(R.string.preference_category_developer)) {
-                    SettingsStringCard(
-                        title = stringResource(R.string.preference_launch_arguments_name),
-                        dialogTitle = stringResource(R.string.preference_launch_arguments_set_title),
-                        preferenceKey = PreferenceUtils.Key.LAUNCH_ARGUMENTS,
-                        filterInput = { it.filter { c ->
-                            // if only there was a better way to define this!
-                            "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*(){}<>[]?:;'\"~`-_+=\\| ".contains(c)
-                        }}
+                    OptionsButton(
+                        title = stringResource(R.string.preferences_view_logs),
+                        icon = {
+                            Icon(painterResource(R.drawable.icon_description), contentDescription = null)
+                        },
+                        onClick = { onOpenLogs(context) }
+                    )
+                    OptionsButton(
+                        title = stringResource(R.string.preference_open_developer_options),
+                        icon = {
+                            Icon(painterResource(R.drawable.icon_data_object), contentDescription = null)
+                        },
+                        onClick = { onOpenDeveloperOptions(context) }
                     )
                     OptionsButton(
                         title = context.getString(R.string.preferences_copy_external_button),
                         description = LaunchUtils.getBaseDirectory(context).path,
                         onClick = { onOpenFolder(context) }
                     )
-                    OptionsButton(
-                        title = stringResource(R.string.preferences_view_logs),
-                        onClick = { onOpenLogs(context) }
-                    )
                 }
 
-                Text(
-                    stringResource(R.string.preference_launcher_version, BuildConfig.VERSION_NAME),
-                    style = Typography.labelSmall,
-                    modifier = Modifier.padding(horizontal = 16.dp, vertical = 4.dp)
-                )
+                OptionsGroup(stringResource(R.string.preference_category_about)) {
+                    val clipboard = LocalClipboardManager.current
+
+                    OptionsButton(
+                        stringResource(R.string.preference_launcher_version_name),
+                        stringResource(R.string.preference_launcher_version_description, BuildConfig.VERSION_NAME),
+                        displayInline = true
+                    ) {
+                        clipboard.setText(AnnotatedString(context.getString(
+                            R.string.preference_launcher_version,
+                            BuildConfig.VERSION_NAME
+                        )))
+                    }
+
+                    OptionsButton(
+                        stringResource(R.string.preference_loader_version_name),
+                        stringResource(R.string.preference_loader_version_description, currentRelease ?: "unknown"),
+                        displayInline = true
+                    ) {
+                        clipboard.setText(AnnotatedString(context.getString(
+                            R.string.preference_loader_version,
+                            currentRelease ?: "unknown"
+                        )))
+                    }
+
+                    val gameInstalled = remember {
+                        GamePackageUtils.isGameInstalled(context.packageManager)
+                    }
+
+                    if (gameInstalled) {
+                        val gameVersion = remember {
+                            GamePackageUtils.getUnifiedVersionName(context.packageManager)
+                        }
+
+                        val gameSource = remember {
+                            context.getString(when (GamePackageUtils.identifyGameSource(context.packageManager)) {
+                                GamePackageUtils.GameSource.GOOGLE -> R.string.preference_game_source_google
+                                GamePackageUtils.GameSource.AMAZON -> R.string.preference_game_source_amazon
+                                else -> R.string.preference_game_source_unknown
+                            })
+                        }
+
+                        OptionsButton(
+                            stringResource(R.string.preference_game_version_name),
+                            stringResource(R.string.preference_game_version_description, gameVersion, gameSource),
+                            displayInline = true
+                        ) {
+                            clipboard.setText(AnnotatedString(context.getString(
+                                R.string.preference_game_version,
+                                gameVersion,
+                                gameSource
+                            )))
+                        }
+
+                        OptionsButton(
+                            stringResource(R.string.preference_architecture_name),
+                            stringResource(R.string.preference_architecture_description, Build.MODEL, LaunchUtils.applicationArchitecture),
+                            displayInline = true
+                        ) {
+                            clipboard.setText(AnnotatedString(context.getString(
+                                R.string.preference_architecture,
+                                Build.MODEL,
+                                LaunchUtils.applicationArchitecture
+                            )))
+                        }
+                    }
+                }
             }
         }
     )

app/src/main/java/com/geode/launcher/preferences/SettingsComponents.kt

@@ -0,0 +1,974 @@
+package com.geode.launcher.preferences
+
+import android.content.Context
+import android.content.Intent
+import androidx.activity.compose.LocalActivity
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.defaultMinSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.selection.toggleable
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Add
+import androidx.compose.material.icons.filled.Clear
+import androidx.compose.material.icons.filled.Delete
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Card
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.RadioButton
+import androidx.compose.material3.Slider
+import androidx.compose.material3.Switch
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.compositionLocalOf
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.staticCompositionLocalOf
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
+import com.geode.launcher.R
+import com.geode.launcher.ui.theme.GeodeLauncherTheme
+import com.geode.launcher.ui.theme.Typography
+import com.geode.launcher.utils.LabelledText
+import com.geode.launcher.utils.PreferenceUtils
+import com.geode.launcher.utils.Profile
+import com.geode.launcher.utils.ProfileManager
+import kotlin.math.log10
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.math.roundToInt
+import kotlin.system.exitProcess
+
+
+fun toggleSetting(context: Context, preferenceKey: PreferenceUtils.Key): Boolean {
+    val preferences = PreferenceUtils.get(context)
+
+    return preferences.toggleBoolean(preferenceKey)
+}
+
+fun getSetting(context: Context, preferenceKey: PreferenceUtils.Key): Boolean {
+    val preferences = PreferenceUtils.get(context)
+
+    return preferences.getBoolean(preferenceKey)
+}
+
+@Composable
+fun OptionsGroup(title: String, content: @Composable () -> Unit) {
+    Column {
+        Text(
+            title,
+            style = Typography.titleMedium,
+            modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp),
+        )
+        content()
+    }
+}
+
+@Composable
+fun SettingsSelectCard(
+    title: String,
+    dialogTitle: String,
+    preferenceKey: PreferenceUtils.Key,
+    options: Map<Int, String>,
+    extraSelectBehavior: ((Int) -> Unit)? = null
+) {
+    val preferenceValue by PreferenceUtils.useIntPreference(preferenceKey)
+
+    var showDialog by remember { mutableStateOf(false) }
+
+    OptionsCard(
+        title = { OptionsTitle(title = title) },
+        modifier = Modifier
+            .clickable(
+                onClick = {
+                    showDialog = true
+                },
+                role = Role.Button
+            )
+    ) {
+        Text(options[preferenceValue] ?: preferenceValue.toString())
+    }
+
+    if (showDialog) {
+        val context = LocalContext.current
+
+        SelectDialog(
+            title = dialogTitle,
+            onDismissRequest = {
+                showDialog = false
+            },
+            onSelect = { selected ->
+                showDialog = false
+                PreferenceUtils.get(context)
+                    .setInt(preferenceKey, selected)
+                extraSelectBehavior?.invoke(selected)
+            },
+            initialValue = preferenceValue,
+        ) {
+            options.forEach { (k, v) ->
+                SelectOption(name = v, value = k)
+            }
+        }
+    }
+}
+
+@Composable
+fun SettingsStringSelectCard(
+    title: String,
+    dialogTitle: String,
+    preferenceKey: PreferenceUtils.Key,
+    options: Map<String, String>,
+    extraSelectBehavior: ((String?) -> Unit)? = null,
+    description: String? = null,
+) {
+    val preferenceValue by PreferenceUtils.useStringPreference(preferenceKey)
+
+    var showDialog by remember { mutableStateOf(false) }
+
+    OptionsCard(
+        title = { OptionsTitle(title = title, description = description) },
+        modifier = Modifier
+            .clickable(
+                onClick = {
+                    showDialog = true
+                },
+                role = Role.Button
+            )
+    ) {
+        Text(options[preferenceValue] ?: preferenceValue ?: "")
+    }
+
+    if (showDialog) {
+        val context = LocalContext.current
+
+        SelectDialog(
+            title = dialogTitle,
+            onDismissRequest = {
+                showDialog = false
+            },
+            onSelect = { selected ->
+                showDialog = false
+                PreferenceUtils.get(context)
+                    .setString(preferenceKey, selected)
+                extraSelectBehavior?.invoke(selected)
+            },
+            initialValue = preferenceValue,
+        ) {
+            options.forEach { (k, v) ->
+                SelectOption(name = v, value = k)
+            }
+        }
+    }
+}
+
+@Composable
+fun SettingsStringCard(
+    title: String,
+    dialogTitle: String,
+    preferenceKey: PreferenceUtils.Key,
+    filterInput: ((String) -> String)? = null
+) {
+    var preferenceValue by PreferenceUtils.useStringPreference(preferenceKey)
+
+    var showDialog by remember { mutableStateOf(false) }
+
+    OptionsCard(
+        title = {
+            OptionsTitle(title = title, description = preferenceValue)
+        },
+        modifier = Modifier
+            .clickable(
+                onClick = {
+                    showDialog = true
+                },
+                role = Role.Button
+            )
+    ) { }
+
+    if (showDialog) {
+        StringDialog(
+            title = dialogTitle,
+            onDismissRequest = { showDialog = false },
+            onSelect = {
+                preferenceValue = it
+                showDialog = false
+            },
+            initialValue = preferenceValue ?: "",
+            filterInput = filterInput
+        )
+    }
+}
+
+@Composable
+fun StringDialog(
+    title: String,
+    onDismissRequest: () -> Unit,
+    onSelect: (String) -> Unit,
+    initialValue: String,
+    filterInput: ((String) -> String)? = null
+) {
+    var enteredValue by remember { mutableStateOf(initialValue) }
+
+    AlertDialog(
+        onDismissRequest = { onDismissRequest() },
+        title = {
+            Text(title)
+        },
+        text = {
+            OutlinedTextField(
+                value = enteredValue,
+                onValueChange = {
+                    enteredValue = filterInput?.invoke(it) ?: it
+                },
+                singleLine = true,
+                keyboardOptions = KeyboardOptions(
+                    keyboardType = KeyboardType.Ascii,
+                    autoCorrectEnabled = false
+                ),
+                trailingIcon = {
+                    if (enteredValue.isNotEmpty()) {
+                        IconButton(onClick = { enteredValue = "" }) {
+                            Icon(
+                                Icons.Filled.Clear,
+                                contentDescription = stringResource(R.string.preference_text_clear)
+                            )
+                        }
+                    }
+                }
+            )
+        },
+        confirmButton = {
+            TextButton(onClick = { onSelect(enteredValue) }) {
+                Text(stringResource(R.string.message_box_accept))
+            }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismissRequest) {
+                Text(stringResource(R.string.message_box_cancel))
+            }
+        },
+    )
+}
+
+@Composable
+fun RangeDialog(
+    title: String,
+    onDismissRequest: () -> Unit,
+    onSelect: (Int) -> Unit,
+    labelSuffix: String,
+    initialValue: Int,
+    range: IntRange,
+    scale: Int,
+    step: Int,
+    children: @Composable () -> Unit
+) {
+    var enteredValue by remember {
+        mutableFloatStateOf(initialValue / scale.toFloat())
+    }
+
+    AlertDialog(
+        onDismissRequest = { onDismissRequest() },
+        title = {
+            Text(title)
+        },
+        text = {
+            Column {
+                Row(
+                    horizontalArrangement = Arrangement.spacedBy(16.dp),
+                    verticalAlignment = Alignment.CenterVertically,
+                    modifier = Modifier.weight(1.0f, false)
+                ) {
+                    val precision = log10(scale.toFloat()).roundToInt()
+
+                    Slider(
+                        value = enteredValue,
+                        onValueChange = { enteredValue = it },
+                        valueRange = (range.first.toFloat()/scale)..(range.last.toFloat()/scale),
+                        steps = ((range.last - range.first) - 1) / step,
+                        modifier = Modifier.weight(1.0f)
+                    )
+
+                    Text("%.${precision}f$labelSuffix".format(enteredValue))
+                }
+
+                children()
+
+            }
+        },
+        confirmButton = {
+            TextButton(onClick = { onSelect((enteredValue * scale).roundToInt()) }) {
+                Text(stringResource(R.string.message_box_accept))
+            }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismissRequest) {
+                Text(stringResource(R.string.message_box_cancel))
+            }
+        },
+    )
+}
+
+@Composable
+fun FrameRateDialog(
+    title: String,
+    onDismissRequest: () -> Unit,
+    onSelect: (Int) -> Unit,
+    initialValue: Int,
+    maxFrameRate: Int,
+) {
+    var enteredValue by remember {
+        mutableStateOf(
+            if (initialValue == 0) maxFrameRate.toString()
+            else initialValue.toString()
+        )
+    }
+
+    val minFrameRate = 5
+    val currentValue = enteredValue.toIntOrNull()
+    val maximumReached = currentValue != null && currentValue > maxFrameRate
+    val minimumReached = currentValue != null && currentValue < minFrameRate
+
+    AlertDialog(
+        onDismissRequest = { onDismissRequest() },
+        title = {
+            Text(title)
+        },
+        text = {
+            Column {
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    modifier = Modifier.weight(1.0f, false)
+                ) {
+                    IconButton(onClick = {
+                        val prevValue = max((currentValue ?: 0) - 5, minFrameRate)
+                        enteredValue = prevValue.toString()
+                    }, enabled = currentValue == null || currentValue > minFrameRate) {
+                        Icon(
+                            painterResource(R.drawable.icon_remove),
+                            contentDescription = stringResource(R.string.preference_limit_framerate_subtract)
+                        )
+                    }
+
+                    Spacer(Modifier.size(8.dp))
+
+                    OutlinedTextField(
+                        value = enteredValue,
+                        onValueChange = {
+                            enteredValue = it
+                        },
+                        singleLine = true,
+                        keyboardOptions = KeyboardOptions(
+                            keyboardType = KeyboardType.Number,
+                        ),
+                        suffix = {
+                            Text(stringResource(R.string.preference_limit_framerate_suffix))
+                        },
+                        label = {
+                            Text(stringResource(R.string.preference_limit_framerate_label))
+                        },
+                        isError = minimumReached || maximumReached,
+                        modifier = Modifier.weight(1.0f),
+                    )
+
+                    Spacer(Modifier.size(8.dp))
+
+                    IconButton(onClick = {
+                        val nextValue = min((currentValue ?: 0) + 5, maxFrameRate)
+                        enteredValue = nextValue.toString()
+                    }, enabled = currentValue == null || currentValue < maxFrameRate) {
+                        Icon(
+                            Icons.Filled.Add,
+                            contentDescription = stringResource(R.string.preference_limit_framerate_add)
+                        )
+                    }
+
+                    IconButton(onClick = { onSelect(0) }) {
+                        Icon(
+                            painterResource(R.drawable.icon_delete),
+                            contentDescription = stringResource(R.string.preference_limit_framerate_reset)
+                        )
+                    }
+                }
+
+
+                if (minimumReached) {
+                    Spacer(Modifier.size(8.dp))
+
+                    Text(
+                        stringResource(R.string.preference_limit_framerate_error_min, minFrameRate),
+                        color = MaterialTheme.colorScheme.error,
+                        style = MaterialTheme.typography.labelLarge,
+                    )
+                } else if (maximumReached) {
+                    Spacer(Modifier.size(8.dp))
+
+                    Text(
+                        stringResource(
+                            R.string.preference_limit_framerate_error_max,
+                            maxFrameRate
+                        ),
+                        color = MaterialTheme.colorScheme.error,
+                        style = MaterialTheme.typography.labelLarge,
+                    )
+                }
+            }
+        },
+        confirmButton = {
+            TextButton(
+                onClick = {
+                    // automatically disable if already max
+                    if (currentValue == maxFrameRate) {
+                        onSelect(0)
+                    } else {
+                        onSelect(currentValue ?: 0)
+                    }
+                },
+                enabled = !minimumReached && !maximumReached && currentValue != null
+            ) {
+                Text(stringResource(R.string.message_box_accept))
+            }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismissRequest) {
+                Text(stringResource(R.string.message_box_cancel))
+            }
+        },
+    )
+}
+
+@Composable
+fun SettingsFPSCard(
+    title: String,
+    dialogTitle: String,
+    preferenceKey: PreferenceUtils.Key,
+    maxFrameRate: Int,
+    description: String? = null,
+) {
+    var preferenceValue by PreferenceUtils.useIntPreference(preferenceKey)
+
+    var showDialog by remember { mutableStateOf(false) }
+
+    OptionsCard(
+        title = { OptionsTitle(title = title, description = description) },
+        modifier = Modifier
+            .clickable(
+                onClick = {
+                    showDialog = true
+                },
+                role = Role.Button
+            )
+    ) {
+        if (preferenceValue == 0) {
+            Text(stringResource(R.string.preference_limit_framerate_default))
+        } else {
+            Text(stringResource(R.string.preference_limit_framerate_value, preferenceValue))
+        }
+    }
+
+    if (showDialog) {
+        FrameRateDialog(
+            title = dialogTitle,
+            onDismissRequest = { showDialog = false },
+            onSelect = {
+                preferenceValue = it
+                showDialog = false
+            },
+            initialValue = preferenceValue,
+            maxFrameRate = maxFrameRate
+        )
+    }
+}
+
+@Composable
+fun SettingsRangeCard(
+    title: String,
+    dialogTitle: String,
+    preferenceKey: PreferenceUtils.Key,
+    labelSuffix: String,
+    range: IntRange,
+    scale: Int,
+    step: Int,
+    description: String? = null,
+    children: @Composable () -> Unit = {}
+) {
+    var preferenceValue by PreferenceUtils.useIntPreference(preferenceKey)
+
+    var showDialog by remember { mutableStateOf(false) }
+
+    OptionsCard(
+        title = {
+            OptionsTitle(title = title, description = description)
+        },
+        modifier = Modifier
+            .clickable(
+                onClick = {
+                    showDialog = true
+                },
+                role = Role.Button
+            )
+    ) {
+        val precision = log10(scale.toFloat()).roundToInt()
+        val scaledValue = preferenceValue / scale.toFloat()
+
+        Text("%.${precision}f$labelSuffix".format(scaledValue))
+    }
+
+    if (showDialog) {
+        RangeDialog(
+            title = dialogTitle,
+            onDismissRequest = { showDialog = false },
+            onSelect = {
+                preferenceValue = it
+                showDialog = false
+            },
+            initialValue = preferenceValue,
+            range = range,
+            scale = scale,
+            labelSuffix = labelSuffix,
+            step = step,
+            children = children,
+        )
+    }
+}
+
+internal val LocalSelectValue = compositionLocalOf<Any> { 0 }
+internal val LocalSelectSetValue = staticCompositionLocalOf<(Any) -> Unit> { {} }
+
+@Composable
+fun <T> SelectOption(name: String, value: T, enabled: Boolean = true, leadingContent: @Composable (Boolean) -> Unit = {}) {
+    val currentValue = LocalSelectValue.current
+    val setValue = LocalSelectSetValue.current
+
+    val isSelected = currentValue.equals(value)
+
+    // do not give the row or column padding!! it messes up the selection effect
+    Row(
+        verticalAlignment = Alignment.CenterVertically,
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable(
+                onClick = { setValue(value as Any) },
+                role = Role.RadioButton,
+                enabled = enabled
+            )
+            .padding(horizontal = 12.dp)
+    ) {
+        Row(modifier = Modifier.weight(1.0f, true), verticalAlignment = Alignment.CenterVertically) {
+            RadioButton(
+                selected = isSelected,
+                onClick = { setValue(value as Any) },
+                enabled = enabled
+            )
+            Text(name, style = Typography.bodyMedium)
+        }
+
+        leadingContent(isSelected)
+    }
+}
+
+@Composable
+fun ProfileCreateDialog(onDismissRequest: () -> Unit) {
+    var enteredValue by remember { mutableStateOf("") }
+
+    val filename = enteredValue.take(16)
+        .lowercase()
+        .map {
+            if ("qwertyuiopasdfghjklzxcvbnm1234567890-_.".contains(it))
+                it else '_'
+        }
+        .joinToString("")
+
+
+    val context = LocalContext.current
+
+    val minimumReached = enteredValue.isEmpty() || filename.isEmpty()
+
+    val profileManager = ProfileManager.get(context)
+    val currentProfiles = remember {
+        profileManager.getProfiles().map { it.path }.toSet()
+    }
+
+    val isDuplicate = currentProfiles.contains(filename)
+
+    AlertDialog(
+        onDismissRequest = { onDismissRequest() },
+        title = {
+            Text(stringResource(R.string.preference_profiles_create))
+        },
+        text = {
+            Column {
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    modifier = Modifier.weight(1.0f, false)
+                ) {
+                    OutlinedTextField(
+                        value = enteredValue,
+                        onValueChange = {
+                            enteredValue = it
+                        },
+                        singleLine = true,
+                        keyboardOptions = KeyboardOptions(
+                            keyboardType = KeyboardType.Text,
+                        ),
+                        label = {
+                            Text(stringResource(R.string.preference_profiles_create_name))
+                        },
+                        isError = isDuplicate
+                    )
+                }
+
+                if (isDuplicate) {
+                    Spacer(Modifier.size(8.dp))
+
+                    Text(stringResource(R.string.preference_profiles_create_duplicate))
+                } else if (!minimumReached) {
+                    Spacer(Modifier.size(8.dp))
+
+                    Text(stringResource(R.string.preference_profiles_create_info, filename))
+                }
+            }
+        },
+        confirmButton = {
+            TextButton(
+                onClick = {
+                    ProfileManager.get(context).storeProfile(Profile(filename, enteredValue))
+                    onDismissRequest()
+                },
+                enabled = !minimumReached && !isDuplicate
+            ) {
+                Text(stringResource(R.string.preference_profiles_create_action))
+            }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismissRequest) {
+                Text(stringResource(R.string.message_box_cancel))
+            }
+        },
+    )
+}
+
+@Composable
+fun ProfileCreateCard() {
+    var showDialog by remember { mutableStateOf(false) }
+
+    OptionsButton(
+        title = stringResource(R.string.preference_profiles_create),
+        icon = {
+            Icon(painterResource(R.drawable.icon_person_add), contentDescription = null)
+        }
+    ) {
+        showDialog = true
+    }
+
+    if (showDialog) {
+        ProfileCreateDialog(onDismissRequest = {
+            showDialog = false
+        })
+    }
+}
+
+@Composable
+fun ProfileSelectCard() {
+    val context = LocalContext.current
+    val profileManager = ProfileManager.get(context)
+
+    val currentProfileId = remember {
+        profileManager.getCurrentProfile()
+    }
+
+    var currentProfileName = remember {
+        val savedProfile = currentProfileId
+        if (savedProfile == null) {
+            "Default"
+        } else {
+            profileManager.getProfile(savedProfile)
+                ?.name ?: savedProfile
+        }
+    }
+
+    val clearedProfiles = remember { mutableStateListOf<String>() }
+
+    val profileList by profileManager.storedProfiles.collectAsState()
+
+    var showDialog by remember { mutableStateOf(false) }
+
+    OptionsButton(
+        title = stringResource(R.string.preference_profiles_select),
+        description = stringResource(R.string.preference_profiles_current, currentProfileName)
+    ) {
+        showDialog = true
+    }
+
+    val activity = LocalActivity.current
+    if (showDialog) {
+        SelectDialog(
+            title = stringResource(R.string.preference_profiles_select),
+            onDismissRequest = {
+                showDialog = false
+            },
+            onSelect = {
+                showDialog = false
+
+                val selectedProfileId = it.takeIf { it.isNotEmpty() }
+
+                if (clearedProfiles.isNotEmpty()) {
+                    profileManager.deleteProfiles(clearedProfiles)
+                }
+
+                if (currentProfileId != selectedProfileId) {
+                    profileManager
+                        .setCurrentProfile(selectedProfileId)
+
+                    activity?.run {
+                        packageManager.getLaunchIntentForPackage(packageName)?.also {
+                            val mainIntent = Intent.makeRestartActivityTask(it.component)
+                            startActivity(mainIntent)
+                            exitProcess(0)
+                        }
+                    }
+                }
+            },
+            initialValue = currentProfileId ?: "",
+        ) {
+            SelectOption("Default", "")
+
+            profileList.forEach { profile ->
+                val path = profile.path
+
+                SelectOption(
+                    stringResource(R.string.preference_profiles_select_value, profile.name, path),
+                    path,
+                    enabled = !clearedProfiles.contains(path),
+                    leadingContent = { selected ->
+                        IconButton(onClick = {
+                            if (clearedProfiles.contains(path)) {
+                                clearedProfiles.remove(path)
+                            } else {
+                                clearedProfiles.add(path)
+                            }
+                        }, enabled = !selected) {
+                            if (clearedProfiles.contains(path)) {
+                                Icon(
+                                    painterResource(R.drawable.icon_undo),
+                                    contentDescription = stringResource(R.string.preference_profiles_delete_undo_alt)
+                                )
+                            } else {
+                                Icon(
+                                    Icons.Filled.Delete,
+                                    contentDescription = stringResource(R.string.preference_profiles_delete_alt)
+                                )
+                            }
+                        }
+                    }
+                )
+            }
+        }
+    }
+}
+
+@Composable
+fun <T> SelectDialog(
+    title: String,
+    onDismissRequest: () -> Unit,
+    onSelect: (T) -> Unit,
+    initialValue: T,
+    options: @Composable () -> Unit,
+) {
+    val (selectedValue, setSelectedValue) = remember { mutableStateOf(initialValue) }
+
+    Dialog(onDismissRequest = onDismissRequest) {
+        Card(
+            shape = RoundedCornerShape(16.dp)
+        ) {
+            // styling a dialog is actually a little hard if you're doing what i'm doing
+            // maybe there's a better way to make these padding values...
+            Column(modifier = Modifier.verticalScroll(rememberScrollState())) {
+                Text(
+                    title,
+                    style = Typography.titleLarge,
+                    modifier = Modifier.padding(
+                        start = 28.dp,
+                        top = 24.dp,
+                        bottom = 12.dp
+                    )
+                )
+
+                CompositionLocalProvider(
+                    LocalSelectValue provides (selectedValue as Any),
+                    LocalSelectSetValue provides ({
+                        @Suppress("UNCHECKED_CAST")
+                        setSelectedValue(it as T)
+                    })
+                ) {
+                    options()
+                }
+
+                Row(
+                    horizontalArrangement = Arrangement.End,
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(
+                            bottom = 16.dp,
+                            end = 16.dp,
+                            top = 4.dp
+                        )
+                ) {
+                    TextButton(onClick = onDismissRequest) {
+                        Text(stringResource(R.string.message_box_cancel))
+                    }
+
+                    TextButton(onClick = { onSelect(selectedValue) }) {
+                        Text(stringResource(R.string.message_box_accept))
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+fun OptionsButton(title: String, description: String? = null, icon: (@Composable () -> Unit)? = null, displayInline: Boolean = false, onClick: () -> Unit) {
+    OptionsCard(
+        title = {
+            OptionsTitle(
+                title = title,
+                description = description.takeIf { !displayInline },
+                icon = icon
+            )
+        },
+        modifier = Modifier
+            .clickable(onClick = onClick, role = Role.Button),
+        wrapContent = true
+    ) {
+        if (displayInline && description != null) {
+            Text(description, textAlign = TextAlign.End)
+        }
+    }
+}
+
+@Composable
+fun SettingsCard(title: String, description: String? = null, icon: (@Composable () -> Unit)? = null, asCard: Boolean = true, preferenceKey: PreferenceUtils.Key) {
+    val context = LocalContext.current
+    val settingEnabled = remember {
+        mutableStateOf(getSetting(context, preferenceKey))
+    }
+
+    OptionsCard(
+        title = {
+            OptionsTitle(
+                title = title,
+                description = description,
+                icon = icon
+            )
+        },
+        modifier = if (asCard) Modifier.toggleable(
+            value = settingEnabled.value,
+            onValueChange = { settingEnabled.value = toggleSetting(context, preferenceKey) },
+            role = Role.Switch,
+        ) else Modifier
+    ) {
+        Switch(
+            checked = settingEnabled.value,
+            onCheckedChange = if (!asCard)
+                { _ -> settingEnabled.value = toggleSetting(context, preferenceKey) }
+            else null
+        )
+    }
+}
+
+@Composable
+fun OptionsTitle(modifier: Modifier = Modifier, title: String, description: String? = null, icon: (@Composable () -> Unit)? = null) {
+    Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+        if (icon != null) {
+            icon()
+        }
+        Column(
+            modifier,
+            verticalArrangement = Arrangement.spacedBy(4.dp),
+        ) {
+            Text(title)
+            if (!description.isNullOrEmpty()) {
+                Text(
+                    description,
+                    style = Typography.labelMedium,
+                    color = MaterialTheme.colorScheme.onSecondaryContainer
+                )
+            }
+        }
+    }
+}
+
+@Composable
+fun OptionsCard(modifier: Modifier = Modifier, wrapContent: Boolean = false, title: @Composable () -> Unit, content: @Composable () -> Unit) {
+    Row(
+        modifier
+            .fillMaxWidth()
+            .defaultMinSize(minHeight = 64.dp)
+            .padding(horizontal = 16.dp),
+        Arrangement.SpaceBetween,
+        Alignment.CenterVertically,
+    ) {
+        if (!wrapContent) {
+            Box(modifier = Modifier.weight(1.0f)) {
+                title()
+            }
+            Spacer(modifier = Modifier.size(12.dp))
+        } else {
+            title()
+        }
+
+        content()
+    }
+}
+
+@Composable
+fun InlineText(label: String, icon: @Composable (() -> Unit)? = null, modifier: Modifier = Modifier) {
+    LabelledText(label = label, icon = icon, modifier = modifier.padding(horizontal = 16.dp, vertical = 4.dp))
+}
+
+@Preview(showBackground = true)
+@Composable
+fun OptionsCardPreview() {
+    GeodeLauncherTheme {
+        OptionsGroup(title = "Preview Group") {
+            SettingsCard(
+                title = "Load files from /test",
+                description = "Very long testing description goes here. It is incredibly long, it should wrap onto a new line.",
+                preferenceKey = PreferenceUtils.Key.BLACK_BACKGROUND
+            )
+            SettingsCard(
+                title = "Testing option 2",
+                preferenceKey = PreferenceUtils.Key.LOAD_AUTOMATICALLY
+            )
+        }
+    }
+}

app/src/main/java/com/geode/launcher/updater/Release.kt

@@ -16,7 +16,7 @@ data class Asset(
 )
 
 @Serializable
-class Release(
+data class Release(
     val url: String,
     val id: Int,
     val targetCommitish: String,
@@ -24,40 +24,86 @@ class Release(
     val createdAt: Instant,
     val publishedAt: Instant,
     val assets: List<Asset>,
-    val htmlUrl: String
-) {
-    fun getDescription(): String {
-        if (tagName == "nightly") {
+    val htmlUrl: String,
+    val body: String?,
+    val name: String?,
+)
+
+@Serializable
+data class LoaderVersion(
+    val tag: String,
+    val version: String,
+    val createdAt: Instant,
+    val commitHash: String,
+    val prerelease: Boolean
+)
+
+@Serializable
+data class LoaderPayload<T>(
+    val payload: T?,
+    val error: String
+)
+
+data class DownloadableAsset(val url: String, val filename: String, val size: Long? = null)
+
+abstract class Downloadable {
+    abstract fun getDescription(): String
+    abstract fun getDescriptor(): Long
+    abstract fun getDownload(): DownloadableAsset?
+}
+
+class DownloadableGitHubLoaderRelease(private val release: Release) : Downloadable() {
+    override fun getDescription(): String {
+        if (release.tagName == "nightly") {
             // get the commit from the assets
             // otherwise, a separate request is needed to get the hash (ew)
-            val asset = assets.first()
+            val asset = release.assets.first()
             val commit = asset.name.substring(6..12)
 
             return "nightly-$commit"
         }
 
-        return tagName
+        return release.tagName
     }
 
-    fun getDescriptor(): Long {
-        return createdAt.epochSeconds
+    override fun getDescriptor(): Long {
+        return release.createdAt.epochSeconds
     }
 
-    fun getGeodeDownload(): Asset? {
+    private fun getGitHubDownload(): Asset? {
         // try to find an asset that matches the architecture first
         val platform = LaunchUtils.platformName
 
         val releaseSuffix = "$platform.zip"
-        return assets.find {
+        return release.assets.find {
             it.name.endsWith(releaseSuffix)
         }
     }
 
-    fun getLauncherDownload(): Asset? {
+    override fun getDownload(): DownloadableAsset? {
+        val download = getGitHubDownload() ?: return null
+        return DownloadableAsset(
+            url = download.browserDownloadUrl,
+            filename = download.name,
+            size = download.size.toLong()
+        )
+    }
+}
+
+class DownloadableLauncherRelease(val release: Release) : Downloadable() {
+    override fun getDescription(): String {
+        return release.tagName
+    }
+
+    override fun getDescriptor(): Long {
+        return release.createdAt.epochSeconds
+    }
+
+    private fun getGitHubDownload(): Asset? {
         val platform = LaunchUtils.platformName
         val use32BitPlatform = platform == "android32"
 
-        return assets.find { asset ->
+        return release.assets.find { asset ->
             /* you know it's good when you pull out the truth table
              * u32bp | contains | found
              * 1     | 1        | 1
@@ -70,4 +116,31 @@ class Release(
             (asset.name.contains("android32")) == use32BitPlatform
         }
     }
+
+    override fun getDownload(): DownloadableAsset? {
+        val download = getGitHubDownload() ?: return null
+        return DownloadableAsset(
+            url = download.browserDownloadUrl,
+            filename = download.name,
+            size = download.size.toLong()
+        )
+    }
+}
+
+class DownloadableLoaderRelease(private val version: LoaderVersion) : Downloadable() {
+    override fun getDescription(): String {
+        return version.tag
+    }
+
+    override fun getDescriptor(): Long {
+        return version.createdAt.epochSeconds
+    }
+
+    override fun getDownload(): DownloadableAsset? {
+        val filename = "geode-${version.tag}-${LaunchUtils.platformName}.zip"
+        return DownloadableAsset(
+            url = "https://github.com/geode-sdk/geode/releases/download/${version.tag}/$filename",
+            filename = filename
+        )
+    }
 }

app/src/main/java/com/geode/launcher/updater/ReleaseManager.kt

@@ -4,6 +4,7 @@ import android.content.Context
 import android.util.Log
 import com.geode.launcher.BuildConfig
 import com.geode.launcher.utils.DownloadUtils
+import com.geode.launcher.utils.GamePackageUtils
 import com.geode.launcher.utils.LaunchUtils
 import com.geode.launcher.utils.PreferenceUtils
 import kotlinx.coroutines.CancellationException
@@ -22,6 +23,9 @@ import okio.source
 import java.io.File
 import java.io.InterruptedIOException
 
+private const val TAG_LATEST = "latest"
+private const val TAG_BETA = "prerelease"
+
 /**
  * Singleton to manage Geode updates, from update checking to downloading.
  */
@@ -57,7 +61,7 @@ class ReleaseManager private constructor(
     sealed class ReleaseManagerState {
         data object InUpdateCheck : ReleaseManagerState()
         data class Failure(val exception: Exception) : ReleaseManagerState()
-        data class InDownload(val downloaded: Long, val outOf: Long) : ReleaseManagerState()
+        data class InDownload(val downloaded: Long, val outOf: Long?) : ReleaseManagerState()
         data class Finished(val hasUpdated: Boolean = false) : ReleaseManagerState()
     }
 
@@ -78,7 +82,7 @@ class ReleaseManager private constructor(
     val isInUpdate: Boolean
         get() = _uiState.value !is ReleaseManagerState.Failure && _uiState.value !is ReleaseManagerState.Finished
 
-    private val _availableLauncherUpdate = MutableStateFlow<Release?>(null)
+    private val _availableLauncherUpdate = MutableStateFlow<DownloadableLauncherRelease?>(null)
     val availableLauncherUpdate = _availableLauncherUpdate.asStateFlow()
 
     private fun sendError(e: Exception) {
@@ -91,24 +95,70 @@ class ReleaseManager private constructor(
         }
     }
 
-    fun dismissLauncherUpdate() {
-        val update = availableLauncherUpdate.value ?: return
-
+    private fun mapSelectedReleaseToTag(): String {
         val sharedPreferences = PreferenceUtils.get(applicationContext)
-        sharedPreferences.setString(PreferenceUtils.Key.LAST_DISMISSED_UPDATE, update.tagName)
+        val releaseChannel = sharedPreferences.getInt(PreferenceUtils.Key.RELEASE_CHANNEL_TAG)
 
-        _availableLauncherUpdate.value = null
+        return when (releaseChannel) {
+            2 -> "nightly"
+            1 -> TAG_BETA
+            else -> TAG_LATEST
+        }
     }
 
-    private suspend fun getLatestRelease(): Release? {
-        val sharedPreferences = PreferenceUtils.get(applicationContext)
-        val useNightly = sharedPreferences.getBoolean(PreferenceUtils.Key.RELEASE_CHANNEL)
-
-        return releaseRepository.getLatestGeodeRelease(useNightly)
+    private fun getBestReleaseForGameVersion(gameVersion: Long): String? = when {
+        gameVersion >= 40L -> mapSelectedReleaseToTag()
+        gameVersion == 39L -> "v3.9.3"
+        gameVersion == 38L -> "v2.0.0-beta.27"
+        gameVersion == 37L -> "v2.0.0-beta.4"
+        else -> null
     }
 
-    private suspend fun performUpdate(release: Release) {
-        val releaseAsset = release.getGeodeDownload()
+    private suspend fun getLatestRelease(): Downloadable? {
+        if (!GamePackageUtils.isGameInstalled(applicationContext.packageManager)) {
+            return null
+        }
+
+        val gameVersion = GamePackageUtils.getGameVersionCode(applicationContext.packageManager)
+        val targetTag = getBestReleaseForGameVersion(gameVersion) ?: return null
+
+        return when (targetTag) {
+            TAG_LATEST -> releaseRepository.getLatestGeodeRelease()
+            TAG_BETA -> releaseRepository.getLatestGeodePreRelease()
+            else -> releaseRepository.getReleaseByTag(targetTag)
+        }
+    }
+
+    private suspend fun downloadLauncherUpdate(release: Downloadable) {
+        val download = release.getDownload() ?: return
+
+        val outputDirectory = LaunchUtils.getBaseDirectory(applicationContext)
+        val outputFile = File(outputDirectory, download.filename)
+
+        if (outputFile.exists()) {
+            // only download the apk once
+            return
+        }
+
+        _uiState.value = ReleaseManagerState.InDownload(0, download.size)
+
+        try {
+            val fileStream = DownloadUtils.downloadStream(
+                httpClient,
+                download.url
+            ) { progress, outOf ->
+                _uiState.value = ReleaseManagerState.InDownload(progress, outOf)
+            }
+
+            fileStream.copyTo(outputFile.outputStream())
+        } catch (e: Exception) {
+            sendError(e)
+            return
+        }
+    }
+
+    private suspend fun performUpdate(release: Downloadable) {
+        val releaseAsset = release.getDownload()
         if (releaseAsset == null) {
             val noAssetException = Exception("missing Android download")
             _uiState.value = ReleaseManagerState.Failure(noAssetException)
@@ -117,12 +167,12 @@ class ReleaseManager private constructor(
         }
 
         // set an initial download size
-        _uiState.value = ReleaseManagerState.InDownload(0, releaseAsset.size.toLong())
+        _uiState.value = ReleaseManagerState.InDownload(0, releaseAsset.size)
 
         try {
             val fileStream = DownloadUtils.downloadStream(
                 httpClient,
-                releaseAsset.browserDownloadUrl
+                releaseAsset.url
             ) { progress, outOf ->
                 _uiState.value = ReleaseManagerState.InDownload(progress, outOf)
             }
@@ -146,18 +196,22 @@ class ReleaseManager private constructor(
             return
         }
 
+        downloadLauncherUpdateIfNecessary()
+
         // extraction performed
         updatePreferences(release)
         _uiState.value = ReleaseManagerState.Finished(true)
     }
 
-    private fun fileWasExternallyModified(): Boolean {
+    private fun fileWasExternallyModified(modifiedOnly: Boolean = false): Boolean {
+        // make sure geode is still here. just in case
         val geodeFile = getGeodeOutputPath()
         if (!geodeFile.exists()) {
-            return false
+            return !modifiedOnly
         }
 
         val sharedPreferences = PreferenceUtils.get(applicationContext)
+
         val originalFileHash = sharedPreferences.getString(PreferenceUtils.Key.CURRENT_RELEASE_MODIFIED)
             ?: return false
 
@@ -166,25 +220,18 @@ class ReleaseManager private constructor(
         return originalFileHash != currentFileHash
     }
 
-    private fun checkLauncherUpdate(launcherUpdate: Release) {
-        if (BuildConfig.DEBUG) {
-            println("ignoring launcher update check - in debug mode!")
-            return
-        }
-
-        val sharedPreferences = PreferenceUtils.get(applicationContext)
-        val lastDismissedVersion = sharedPreferences.getString(PreferenceUtils.Key.LAST_DISMISSED_UPDATE)
-
-        if (!lastDismissedVersion.isNullOrEmpty() && launcherUpdate.tagName == lastDismissedVersion) {
-            return
-        }
-
-        if (launcherUpdate.tagName != BuildConfig.VERSION_NAME) {
+    private fun checkLauncherUpdate(launcherUpdate: DownloadableLauncherRelease) {
+        if (launcherUpdate.release.tagName != BuildConfig.VERSION_NAME) {
             _availableLauncherUpdate.value = launcherUpdate
         }
     }
 
-    private suspend fun checkForNewRelease(allowOverwriting: Boolean = false) {
+    private suspend fun downloadLauncherUpdateIfNecessary() {
+        val update = _availableLauncherUpdate.value ?: return
+        downloadLauncherUpdate(update)
+    }
+
+    private suspend fun checkForNewRelease(isManual: Boolean = false) {
         val release = try {
             getLatestRelease()
         } catch (e: Exception) {
@@ -204,6 +251,8 @@ class ReleaseManager private constructor(
         }
 
         if (release == null) {
+            downloadLauncherUpdateIfNecessary()
+
             _uiState.value = ReleaseManagerState.Finished()
             return
         }
@@ -213,17 +262,20 @@ class ReleaseManager private constructor(
         val currentVersion = sharedPreferences.getLong(PreferenceUtils.Key.CURRENT_VERSION_TIMESTAMP)
         val latestVersion = release.getDescriptor()
 
-        // make sure geode is still here. just in case
-        val geodeFile = getGeodeOutputPath()
-
         // check if an update is needed
-        if (latestVersion == currentVersion && geodeFile.exists()) {
+        if (latestVersion == currentVersion && !fileWasExternallyModified()) {
+            downloadLauncherUpdateIfNecessary()
+
             _uiState.value = ReleaseManagerState.Finished()
             return
         }
 
+        val allowOverwriting = !sharedPreferences.getBoolean(PreferenceUtils.Key.DEVELOPER_MODE) || isManual
+
         // check if the file was externally modified
-        if (!allowOverwriting && fileWasExternallyModified()) {
+        if (!allowOverwriting && fileWasExternallyModified(true)) {
+            downloadLauncherUpdateIfNecessary()
+
             sendError(UpdateException(UpdateException.Reason.EXTERNAL_FILE_IN_USE))
             return
         }
@@ -231,7 +283,7 @@ class ReleaseManager private constructor(
         performUpdate(release)
     }
 
-    private fun updatePreferences(release: Release) {
+    private fun updatePreferences(release: Downloadable) {
         val sharedPreferences = PreferenceUtils.get(applicationContext)
 
         sharedPreferences.setString(
@@ -286,4 +338,4 @@ class ReleaseManager private constructor(
 
         return _uiState.asStateFlow()
     }
-}
+}

app/src/main/java/com/geode/launcher/updater/ReleaseRepository.kt

@@ -1,10 +1,15 @@
 package com.geode.launcher.updater
 
 import com.geode.launcher.utils.DownloadUtils.executeCoroutine
+import kotlinx.datetime.Clock
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.Instant
+import kotlinx.datetime.until
 import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonNamingStrategy
 import kotlinx.serialization.json.okio.decodeFromBufferedSource
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
 import okhttp3.OkHttpClient
 import okhttp3.Request
 import java.io.IOException
@@ -15,24 +20,97 @@ class ReleaseRepository(private val httpClient: OkHttpClient) {
         private const val GITHUB_API_BASE = "https://api.github.com"
         private const val GITHUB_API_HEADER = "X-GitHub-Api-Version"
         private const val GITHUB_API_VERSION = "2022-11-28"
+
+        private const val GITHUB_RATELIMIT_REMAINING = "x-ratelimit-remaining"
+        private const val GITHUB_RATELIMIT_RESET = "x-ratelimit-reset"
+
+        private const val GEODE_API_BASE = "https://api.geode-sdk.org/v1"
     }
 
-    suspend fun getLatestLauncherRelease(): Release? {
-        val releasePath = "$GITHUB_API_BASE/repos/geode-sdk/android-launcher/releases/latest"
+    suspend fun getLatestLauncherRelease(): DownloadableLauncherRelease? {
+        val releasePath = "$GITHUB_API_BASE/repos/Lncvrt/xps-geode-launcher/releases/latest"
 
         val url = URL(releasePath)
 
-        return getReleaseByUrl(url)
+        return getReleaseByUrl(url)?.let(::DownloadableLauncherRelease)
     }
 
-    suspend fun getLatestGeodeRelease(isNightly: Boolean = false): Release? {
-        val geodeBaseUrl = "$GITHUB_API_BASE/repos/geode-sdk/geode/releases"
-        val releasePath = if (isNightly) "$geodeBaseUrl/tags/nightly"
-            else "$geodeBaseUrl/latest"
-
+    suspend fun getLatestGeodeRelease(): DownloadableGitHubLoaderRelease? {
+        val releasePath = "$GITHUB_API_BASE/repos/geode-sdk/geode/releases/latest"
         val url = URL(releasePath)
 
-        return getReleaseByUrl(url)
+        return getReleaseByUrl(url)?.let(::DownloadableGitHubLoaderRelease)
+    }
+
+    suspend fun getReleaseByTag(tag: String): DownloadableGitHubLoaderRelease? {
+        val releasePath = "$GITHUB_API_BASE/repos/geode-sdk/geode/releases/tags/$tag"
+        val url = URL(releasePath)
+
+        return getReleaseByUrl(url)?.let(::DownloadableGitHubLoaderRelease)
+    }
+
+    @OptIn(ExperimentalSerializationApi::class)
+    suspend fun getLatestGeodePreRelease(): DownloadableGitHubLoaderRelease? {
+        val releasesUrl = "$GITHUB_API_BASE/repos/geode-sdk/geode/releases?per_page=2"
+        val url = URL(releasesUrl)
+
+        val request = Request.Builder()
+            .url(url)
+            .addHeader("Accept", "application/json")
+            .addHeader(GITHUB_API_HEADER, GITHUB_API_VERSION)
+            .build()
+
+        val call = httpClient.newCall(request)
+        val response = call.executeCoroutine()
+
+        return when (response.code) {
+            200 -> {
+                val format = Json {
+                    namingStrategy = JsonNamingStrategy.SnakeCase
+                    ignoreUnknownKeys = true
+                }
+
+                val release = format.decodeFromBufferedSource<List<Release>>(
+                    response.body!!.source()
+                )
+
+                (release.find { it.tagName != "nightly" })
+                    ?.let(::DownloadableGitHubLoaderRelease)
+            }
+            403 -> {
+                // determine if the error code is a ratelimit
+                // (github docs say it sends 429 too, but haven't seen that)
+
+                val limitRemaining = response.headers.get(GITHUB_RATELIMIT_REMAINING)?.toInt()
+                val limitReset = response.headers.get(GITHUB_RATELIMIT_RESET)?.toLong()
+
+                if (limitRemaining == 0 && limitReset != null) {
+                    // handle ratelimit with a custom error
+                    // there's also a retry-after header but again, haven't seen
+                    val resetTime = Instant.fromEpochSeconds(limitReset, 0L)
+                    val msg = generateRateLimitMessage(resetTime)
+
+                    throw IOException(msg)
+                }
+
+                throw IOException("response 403: ${response.body!!.string()}")
+            }
+            404 -> {
+                null
+            }
+            else -> {
+                throw IOException("unknown response ${response.code}")
+            }
+        }
+    }
+
+    private fun generateRateLimitMessage(resetTime: Instant): String {
+        val currentTime = Clock.System.now()
+        val resetDelay = currentTime.until(resetTime, DateTimeUnit.SECOND)
+
+        val formattedWait = "${resetDelay / 60}m"
+
+        return "api ratelimit reached, try again in ${formattedWait}"
     }
 
     @OptIn(ExperimentalSerializationApi::class)
@@ -59,6 +137,65 @@ class ReleaseRepository(private val httpClient: OkHttpClient) {
 
                 release
             }
+            403 -> {
+                // determine if the error code is a ratelimit
+                // (github docs say it sends 429 too, but haven't seen that)
+
+                val limitRemaining = response.headers[GITHUB_RATELIMIT_REMAINING]?.toInt()
+                val limitReset = response.headers[GITHUB_RATELIMIT_RESET]?.toLong()
+
+                if (limitRemaining == 0 && limitReset != null) {
+                    // handle ratelimit with a custom error
+                    // there's also a retry-after header but again, haven't seen
+                    val resetTime = Instant.fromEpochSeconds(limitReset, 0L)
+                    val msg = generateRateLimitMessage(resetTime)
+
+                    throw IOException(msg)
+                }
+
+                throw IOException("response 403: ${response.body!!.string()}")
+            }
+            404 -> {
+                null
+            }
+            else -> {
+                throw IOException("unknown response ${response.code}")
+            }
+        }
+    }
+
+    @OptIn(ExperimentalSerializationApi::class)
+    suspend fun getLatestIndexRelease(gd: String, prerelease: Boolean = false): DownloadableLoaderRelease? {
+        val url = "$GEODE_API_BASE/loader/versions/latest".toHttpUrlOrNull()!!
+            .newBuilder()
+            .addQueryParameter("gd", gd)
+            .addQueryParameter("platform", "android")
+            .addQueryParameter("prerelease", prerelease.toString())
+            .build()
+
+        val request = Request.Builder()
+            .url(url)
+            .addHeader("Accept", "application/json")
+            .build()
+
+        val call = httpClient.newCall(request)
+        val response = call.executeCoroutine()
+
+        return when (response.code) {
+            200 -> {
+                val format = Json {
+                    namingStrategy = JsonNamingStrategy.SnakeCase
+                    ignoreUnknownKeys = true
+                }
+
+                val body = format.decodeFromBufferedSource<LoaderPayload<LoaderVersion>>(
+                    response.body!!.source()
+                )
+
+                val release = body.payload ?: throw IOException("index error: ${body.error}")
+
+                DownloadableLoaderRelease(release)
+            }
             404 -> {
                 null
             }

app/src/main/java/com/geode/launcher/updater/ReleaseViewModel.kt

@@ -30,7 +30,7 @@ class ReleaseViewModel(private val application: Application): ViewModel() {
     sealed class ReleaseUIState {
         data object InUpdateCheck : ReleaseUIState()
         data class Failure(val exception: Exception) : ReleaseUIState()
-        data class InDownload(val downloaded: Long, val outOf: Long) : ReleaseUIState()
+        data class InDownload(val downloaded: Long, val outOf: Long?) : ReleaseUIState()
         data class Finished(val hasUpdated: Boolean = false) : ReleaseUIState()
         data class Cancelled(val isCancelling: Boolean = false) : ReleaseUIState()
 
@@ -98,10 +98,4 @@ class ReleaseViewModel(private val application: Application): ViewModel() {
             syncUiState(releaseFlow)
         }
     }
-
-    fun dismissLauncherUpdate() {
-        viewModelScope.launch(Dispatchers.IO) {
-            ReleaseManager.get(application).dismissLauncherUpdate()
-        }
-    }
 }

app/src/main/java/com/geode/launcher/utils/Components.kt

@@ -0,0 +1,46 @@
+package com.geode.launcher.utils
+
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.text.InlineTextContent
+import androidx.compose.foundation.text.appendInlineContent
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.Placeholder
+import androidx.compose.ui.text.PlaceholderVerticalAlign
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.unit.sp
+
+@Composable
+fun LabelledText(label: String, icon: @Composable (() -> Unit)? = null, modifier: Modifier = Modifier) {
+    if (icon != null) {
+        val iconId = "inlineIcon"
+        val paddingId = "paddingIcon"
+
+        val labelText = buildAnnotatedString {
+            appendInlineContent(iconId, "[x]")
+            appendInlineContent(paddingId, " ")
+            append(label)
+        }
+
+        val inlineContent = mapOf(
+            Pair(iconId, InlineTextContent(
+                Placeholder(
+                width = 24.sp,
+                height = 24.sp,
+                placeholderVerticalAlign = PlaceholderVerticalAlign.TextCenter
+            )
+            ) {
+                icon()
+            }),
+            Pair(paddingId, InlineTextContent(Placeholder(width = 6.sp, height = 24.sp, placeholderVerticalAlign = PlaceholderVerticalAlign.Center)) {
+                Spacer(modifier = Modifier.fillMaxWidth())
+            })
+        )
+
+        Text(text = labelText, inlineContent = inlineContent, modifier = modifier)
+    } else {
+        Text(label, modifier = modifier)
+    }
+}

app/src/main/java/com/geode/launcher/utils/Constants.kt

@@ -3,7 +3,7 @@ package com.geode.launcher.utils
 import android.annotation.SuppressLint
 
 object Constants {
-    const val PACKAGE_NAME = "com.robtopx.geometryjump"
+    const val PACKAGE_NAME = "xyz.lncvrt.xps0000002200"
 
     const val COCOS_LIB_NAME = "cocos2dcpp"
     const val FMOD_LIB_NAME = "fmod"
@@ -13,6 +13,14 @@ object Constants {
     @SuppressLint("SdCardPath")
     const val GJ_DATA_DIR = "/data/data/${PACKAGE_NAME}"
 
-    const val SUPPORTED_VERSION_CODE = 38L
-    const val SUPPORTED_VERSION_STRING = "2.205"
+    // anything below this version code is blocked from opening the game
+    const val SUPPORTED_VERSION_CODE_MIN = 37L
+
+    // anything below this version code shows a warning on the main menu
+    const val SUPPORTED_VERSION_CODE_MIN_WARNING = 40L
+
+    // anything above this version code will show a warning when starting the game
+    const val SUPPORTED_VERSION_CODE = 40L
+
+    const val SUPPORTED_VERSION_STRING = "2.2.143"
 }

app/src/main/java/com/geode/launcher/utils/ConstrainedFrameLayout.kt

@@ -2,26 +2,71 @@ package com.geode.launcher.utils
 
 import android.content.Context
 import android.widget.FrameLayout
+import kotlin.math.ceil
+import kotlin.math.floor
+import kotlin.math.min
 
 class ConstrainedFrameLayout(context: Context) : FrameLayout(context) {
     // avoid running the aspect ratio fix when we don't need it
-    var aspectRatio: Float? = null;
+    var aspectRatio: Float? = null
+    var zoom: Float? = null
+    var fitZoom: Boolean = false
 
     override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
-        if (aspectRatio != null) {
+        var paddingX = 0.0f
+        var paddingY = 0.0f
+
+        val currentZoom = zoom
+        if (currentZoom != null) {
             val width = MeasureSpec.getSize(widthMeasureSpec)
             val height = MeasureSpec.getSize(heightMeasureSpec)
             if (width == 0 || height == 0) {
                 super.onMeasure(widthMeasureSpec, heightMeasureSpec)
+                return
             }
 
-            val calculatedWidth = height * (aspectRatio ?: 1.0f);
-            val padding = ((width - calculatedWidth) / 2).toInt()
+            val calculatedWidth = width * currentZoom
+            val calculatedHeight = height * currentZoom
 
-            // ignore paddings where the screen ends up looking odd
-            if (padding > 0) {
-                setPadding(padding, 0, padding, 0)
+            paddingX = (width - calculatedWidth)/2
+            paddingY = (height - calculatedHeight)/2
+        }
+
+        val currentAspectRatio = aspectRatio
+        if (currentAspectRatio != null) {
+            val width = MeasureSpec.getSize(widthMeasureSpec)
+            val height = MeasureSpec.getSize(heightMeasureSpec)
+            if (width == 0 || height == 0) {
+                super.onMeasure(widthMeasureSpec, heightMeasureSpec)
+                return
             }
+
+            val calculatedWidth = (height - paddingY * 2) * currentAspectRatio
+            val padding = (width - calculatedWidth) / 2
+
+            paddingX = padding
+        }
+
+        if (paddingX > 0.0 || paddingY > 0.0) {
+            if (fitZoom) {
+                val width = MeasureSpec.getSize(widthMeasureSpec)
+                val height = MeasureSpec.getSize(heightMeasureSpec)
+
+                val calculatedHeight = (height - paddingY * 2)
+                val calculatedWidth = (width - paddingX * 2)
+
+                val zoomFactor = min(height / calculatedHeight, width / calculatedWidth)
+
+                scaleX = zoomFactor
+                scaleY = zoomFactor
+            }
+
+            setPadding(
+                ceil(paddingX).toInt(),
+                ceil(paddingY).toInt(),
+                floor(paddingX).toInt(),
+                floor(paddingY).toInt()
+            )
         }
 
         super.onMeasure(

app/src/main/java/com/geode/launcher/utils/GamePackageUtils.kt

@@ -0,0 +1,163 @@
+package com.geode.launcher.utils
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.pm.ApplicationInfo
+import android.content.pm.PackageInfo
+import android.content.pm.PackageManager
+import android.content.res.AssetManager
+import android.os.Build
+import android.util.Log
+import okio.ByteString.Companion.toByteString
+
+object GamePackageUtils {
+    fun isGameInstalled(packageManager: PackageManager): Boolean {
+        return try {
+            packageManager.getPackageInfo(Constants.PACKAGE_NAME, 0)
+            true
+        } catch (e: PackageManager.NameNotFoundException) {
+            false
+        }
+    }
+
+    fun showDownloadBadge(packageManager: PackageManager) =
+        !isGameInstalled(packageManager) || !identifyGameLegitimacy(packageManager)
+
+    fun getGameVersionCode(packageManager: PackageManager): Long {
+        val game = packageManager.getPackageInfo(Constants.PACKAGE_NAME, 0)
+
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            game.longVersionCode
+        } else {
+            @Suppress("DEPRECATION")
+            game.versionCode.toLong()
+        }
+    }
+
+    fun getGameVersionCodeOrNull(packageManager: PackageManager): Long? {
+        return try {
+            getGameVersionCode(packageManager)
+        } catch (e: PackageManager.NameNotFoundException) {
+            null
+        }
+    }
+
+    fun getGameVersionString(packageManager: PackageManager): String {
+        val game = packageManager.getPackageInfo(Constants.PACKAGE_NAME, 0)
+        return game.versionName ?: "0.000"
+    }
+
+    private val gameVersionMap = mapOf(
+        37L to "2.200",
+        38L to "2.205",
+        39L to "2.206",
+        40L to "2.2074" // ok
+    )
+
+    /**
+     * Gets the version name that more closely aligns to the Windows/macOS releases
+     */
+    fun getUnifiedVersionName(packageManager: PackageManager): String {
+        val versionCode = getGameVersionCode(packageManager)
+        return gameVersionMap[versionCode] ?: getGameVersionString(packageManager)
+    }
+
+    fun detectAbiMismatch(context: Context, packageInfo: PackageInfo, loadException: Error): Boolean {
+        val abi = LaunchUtils.applicationArchitecture
+        val isExtracted =
+            packageInfo.applicationInfo!!.flags and ApplicationInfo.FLAG_EXTRACT_NATIVE_LIBS == ApplicationInfo.FLAG_EXTRACT_NATIVE_LIBS
+        val isSplit = (packageInfo.applicationInfo?.splitSourceDirs?.size ?: 0) > 1
+
+        val metadata =
+            "Geometry Dash metadata:\nSplit sources: $isSplit\nExtracted libraries: $isExtracted\nLauncher architecture: $abi"
+        Log.i("GeodeLauncher", metadata)
+
+        // easiest check! these messages are hardcoded in bionic/linker/linker_phdr.cpp
+        if (loadException.message?.contains("32-bit instead of 64-bit") == true) {
+            return true
+        }
+
+        if (loadException.message?.contains("64-bit instead of 32-bit") == true) {
+            return true
+        }
+
+        // determine if it can find gd libraries for the opposite architecture
+        val gdBinaryName = "lib${Constants.COCOS_LIB_NAME}.so"
+        val oppositeArchitecture = if (abi == "arm64-v8a") "armeabi-v7a" else "arm64-v8a"
+
+        // detect issues using native library directory (only works on extracted libraries)
+        val nativeLibraryDir = packageInfo.applicationInfo!!.nativeLibraryDir
+
+        if (nativeLibraryDir.contains(oppositeArchitecture)) {
+            return true
+        }
+
+        // android has some odd behavior where 32bit libraries get installed to the arm directory instead of armeabi-v7a
+        // detect it, ig
+        if (oppositeArchitecture == "armeabi-v7a" && nativeLibraryDir.contains("/lib/arm/")) {
+            return true
+        }
+
+        if (!isExtracted) {
+            try {
+                context.assets.openNonAssetFd("lib/$oppositeArchitecture/$gdBinaryName")
+                return true
+            } catch (_: Exception) {
+                // this is good, actually!
+            }
+        }
+
+        return false
+    }
+
+    @SuppressLint("DiscouragedPrivateApi")
+    fun addAssetsFromPackage(assetManager: AssetManager, packageInfo: PackageInfo) {
+        // this method is officially marked as deprecated but it is the only method we are allowed to reflect
+        // (the source recommends replacing with AssetManager.setApkAssets(ApkAssets[], boolean) lol)
+        val clazz = assetManager.javaClass
+        val aspMethod = clazz.getDeclaredMethod("addAssetPath", String::class.java)
+
+        aspMethod.invoke(assetManager, packageInfo.applicationInfo?.sourceDir)
+        packageInfo.applicationInfo?.splitSourceDirs?.forEach {
+            aspMethod.invoke(assetManager, it)
+        }
+    }
+
+    private const val GAME_CERTIFICATE_HASH = "f5e7d8284d72c461a5f022d0cf755df101c3bb1e69cbe241bc1aef2cc5610a43"
+    private const val AMAZON_CERTIFICATE_HASH = "1f228081e4d66e006887d4ba0f3d40e96a80c758b84231f11cd5c1c9aef6048f"
+
+    private fun validateCertificate(certificate: ByteArray): GameSource = when (val hash = certificate.toByteString().sha256().hex()) {
+        GAME_CERTIFICATE_HASH -> GameSource.GOOGLE
+        AMAZON_CERTIFICATE_HASH -> GameSource.AMAZON
+        else -> {
+            println("Encountered certificate hash: $hash")
+            GameSource.UNKNOWN
+        }
+    }
+
+    enum class GameSource {
+        UNKNOWN, GOOGLE, AMAZON
+    }
+
+    fun identifyGameSource(packageManager: PackageManager): GameSource {
+        @Suppress("DEPRECATION")
+        val certificates = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            val game = packageManager.getPackageInfo(Constants.PACKAGE_NAME, PackageManager.GET_SIGNING_CERTIFICATES)
+            val signingInfo = game.signingInfo
+
+            signingInfo?.signingCertificateHistory ?: return GameSource.UNKNOWN
+        } else {
+            val game = packageManager.getPackageInfo(Constants.PACKAGE_NAME, PackageManager.GET_SIGNATURES)
+            game.signatures
+        }
+
+        return certificates?.map {
+            validateCertificate(it.toByteArray())
+        }?.firstOrNull {
+            it != GameSource.UNKNOWN
+        } ?: GameSource.UNKNOWN
+    }
+
+    fun identifyGameLegitimacy(packageManager: PackageManager) =
+        identifyGameSource(packageManager) != GameSource.UNKNOWN
+}

app/src/main/java/com/geode/launcher/utils/GeodeUtils.kt

@@ -10,12 +10,16 @@ import android.content.pm.PackageManager
 import android.net.Uri
 import android.os.Build
 import android.os.Environment
+import android.os.VibrationEffect
+import android.os.Vibrator
+import android.os.VibratorManager
 import android.provider.DocumentsContract
 import android.provider.Settings.ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION
 import android.util.Log
 import android.widget.Toast
 import androidx.activity.result.ActivityResultLauncher
 import androidx.activity.result.contract.ActivityResultContracts
+import androidx.annotation.Keep
 import androidx.appcompat.app.AppCompatActivity
 import androidx.core.content.ContextCompat
 import androidx.documentfile.provider.DocumentFile
@@ -29,6 +33,7 @@ import java.io.File
 import java.lang.ref.WeakReference
 import kotlin.system.exitProcess
 
+@Keep
 @Suppress("unused", "KotlinJniMissingFunction")
 object GeodeUtils {
     private lateinit var activity: WeakReference<AppCompatActivity>
@@ -52,20 +57,37 @@ object GeodeUtils {
                     selectFileCallback(path)
                     return@registerForActivityResult
                 }
+
+                Toast.makeText(activity, R.string.file_select_error, Toast.LENGTH_SHORT)
+                    .show()
+            } else {
+                Toast.makeText(activity, R.string.no_file_selected, Toast.LENGTH_SHORT)
+                    .show()
             }
+
             failedCallback()
         }
         openDirectoryResultLauncher = activity.registerForActivityResult(ActivityResultContracts.OpenDocumentTree()) {
             if (it != null) {
                 val path = FileUtils.getRealPathFromURI(activity, it)
-                if (path != null)
+                if (path != null) {
                     selectFileCallback(path)
-                return@registerForActivityResult
+                    return@registerForActivityResult
+                }
+
+                Toast.makeText(activity, R.string.file_select_error, Toast.LENGTH_SHORT)
+                    .show()
+            } else {
+                Toast.makeText(activity, R.string.no_file_selected, Toast.LENGTH_SHORT)
+                    .show()
             }
             failedCallback()
         }
         openFilesResultLauncher = activity.registerForActivityResult(GeodeOpenFilesActivityResult()) { result ->
             if (result.isEmpty()) {
+                Toast.makeText(activity, R.string.no_file_selected, Toast.LENGTH_SHORT)
+                    .show()
+
                 failedCallback()
                 return@registerForActivityResult
             }
@@ -86,6 +108,12 @@ object GeodeUtils {
                     selectFileCallback(path)
                     return@registerForActivityResult
                 }
+
+                Toast.makeText(activity, R.string.file_select_error, Toast.LENGTH_SHORT)
+                    .show()
+            } else {
+                Toast.makeText(activity, R.string.no_file_selected, Toast.LENGTH_SHORT)
+                    .show()
             }
             failedCallback()
         }
@@ -147,7 +175,7 @@ object GeodeUtils {
             val manager = getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
             val clip = manager.primaryClip
             if (clip != null && clip.itemCount > 0) {
-                return clip.getItemAt(0).text.toString()
+                return clip.getItemAt(0).coerceToText(this).toString()
             }
         }
         return ""
@@ -348,22 +376,21 @@ object GeodeUtils {
         return activity.filesDir.canonicalPath
     }
 
-    private val gameVersionMap = mapOf(
-        37L to "2.200",
-        38L to "2.205"
-    )
-
     @JvmStatic
     fun getGameVersion(): String {
         // these versions should be aligned to windows releases, not what android says
         activity.get()?.run {
-            val versionCode = LaunchUtils.getGeometryDashVersionCode(packageManager)
-            return gameVersionMap[versionCode] ?: LaunchUtils.getGeometryDashVersionString(packageManager)
+            return GamePackageUtils.getUnifiedVersionName(packageManager)
         }
 
         return ""
     }
 
+    @JvmStatic
+    fun getLauncherVersion(): Int {
+        return BuildConfig.VERSION_CODE
+    }
+
     fun isGeodeUri(uri: Uri): Boolean {
         return "com.geode.launcher.user" == uri.authority
     }
@@ -419,6 +446,40 @@ object GeodeUtils {
 
     private external fun permissionCallback(granted: Boolean)
 
+    internal fun getVibrator(): Vibrator? = activity.get()?.run {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            val manager = getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as VibratorManager
+            manager.defaultVibrator
+        } else {
+            @Suppress("DEPRECATION")
+            getSystemService(Context.VIBRATOR_SERVICE) as Vibrator
+        }
+    }
+
+    // vibration
+    @JvmStatic
+    fun vibrateSupported(): Boolean = getVibrator()?.hasVibrator() == true
+
+    @JvmStatic
+    fun vibrate(ms: Long) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            getVibrator()?.vibrate(VibrationEffect.createOneShot(ms, VibrationEffect.DEFAULT_AMPLITUDE))
+        } else {
+            @Suppress("DEPRECATION")
+            getVibrator()?.vibrate(ms)
+        }
+    }
+
+    @JvmStatic
+    fun vibratePattern(pattern: LongArray, repeat: Int) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            getVibrator()?.vibrate(VibrationEffect.createWaveform(pattern, repeat))
+        } else {
+            @Suppress("DEPRECATION")
+            getVibrator()?.vibrate(pattern, repeat)
+        }
+    }
+
     const val ARGUMENT_SAFE_MODE = "--geode:safe-mode"
 
     private var additionalLaunchArguments = arrayListOf<String>()
@@ -449,6 +510,7 @@ object GeodeUtils {
     }
 
     const val CAPABILITY_EXTENDED_INPUT = "extended_input"
+    const val CAPABILITY_TIMESTAMP_INPUT = "timestamp_inputs"
 
     private var capabilityListener: WeakReference<CapabilityListener?> = WeakReference(null)
 
@@ -462,11 +524,14 @@ object GeodeUtils {
             return false
         }
 
-        return capabilityListener.get()?.onCapabilityAdded(capability) ?: false
+        return capabilityListener.get()?.onCapabilityAdded(capability) == true
     }
 
     external fun nativeKeyUp(keyCode: Int, modifiers: Int)
     external fun nativeKeyDown(keyCode: Int, modifiers: Int, isRepeating: Boolean)
     external fun nativeActionScroll(scrollX: Float, scrollY: Float)
     external fun resizeSurface(width: Int, height: Int)
+
+    // represents the timestamp of the next input callback, in nanoseconds (most events don't send it, but it's there)
+    external fun setNextInputTimestamp(timestamp: Long)
 }

app/src/main/java/com/geode/launcher/utils/LaunchUtils.kt

@@ -1,89 +1,11 @@
 package com.geode.launcher.utils
 
-import android.annotation.SuppressLint
-import android.content.pm.PackageInfo
-import android.content.pm.PackageManager
-import android.content.res.AssetManager
 import android.content.Context
-import android.content.pm.ApplicationInfo
 import android.os.Build
-import android.util.Log
 import java.io.File
+import java.io.Serializable
 
 object LaunchUtils {
-    fun isGeometryDashInstalled(packageManager: PackageManager): Boolean {
-        return try {
-            packageManager.getPackageInfo(Constants.PACKAGE_NAME, 0)
-            true
-        } catch (e: PackageManager.NameNotFoundException) {
-            false
-        }
-    }
-
-    fun getGeometryDashVersionCode(packageManager: PackageManager): Long {
-        val game = packageManager.getPackageInfo(Constants.PACKAGE_NAME, 0)
-
-        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
-            game.longVersionCode
-        } else {
-            @Suppress("DEPRECATION")
-            game.versionCode.toLong()
-        }
-    }
-
-    fun getGeometryDashVersionString(packageManager: PackageManager): String {
-        val game = packageManager.getPackageInfo(Constants.PACKAGE_NAME, 0)
-        return game.versionName
-    }
-
-    fun detectAbiMismatch(context: Context, packageInfo: PackageInfo, loadException: Error): Boolean {
-        val abi = applicationArchitecture
-        val isExtracted =
-            packageInfo.applicationInfo.flags and ApplicationInfo.FLAG_EXTRACT_NATIVE_LIBS == ApplicationInfo.FLAG_EXTRACT_NATIVE_LIBS
-        val isSplit = (packageInfo.applicationInfo.splitSourceDirs?.size ?: 0) > 1
-
-        val metadata =
-            "Geometry Dash metadata:\nSplit sources: $isSplit\nExtracted libraries: $isExtracted\nLauncher architecture: $abi"
-        Log.i("GeodeLauncher", metadata)
-
-        // easiest check! these messages are hardcoded in bionic/linker/linker_phdr.cpp
-        if (loadException.message?.contains("32-bit instead of 64-bit") == true) {
-            return true
-        }
-
-        if (loadException.message?.contains("64-bit instead of 32-bit") == true) {
-            return true
-        }
-
-        // determine if it can find gd libraries for the opposite architecture
-        val gdBinaryName = "lib${Constants.COCOS_LIB_NAME}.so"
-        val oppositeArchitecture = if (abi == "arm64-v8a") "armeabi-v7a" else "arm64-v8a"
-
-        // detect issues using native library directory (only works on extracted libraries)
-        val nativeLibraryDir = packageInfo.applicationInfo.nativeLibraryDir
-
-        if (nativeLibraryDir.contains(oppositeArchitecture)) {
-            return true
-        }
-
-        // android has some odd behavior where 32bit libraries get installed to the arm directory instead of armeabi-v7a
-        // detect it, ig
-        if (oppositeArchitecture == "armeabi-v7a" && nativeLibraryDir.contains("/lib/arm/")) {
-            return true
-        }
-
-        if (!isExtracted) {
-            try {
-                context.assets.openNonAssetFd("lib/$oppositeArchitecture/$gdBinaryName")
-                return true
-            } catch (_: Exception) {
-                // this is good, actually!
-            }
-        }
-
-        return false
-    }
-
     // supposedly CPU_ABI returns the current arch for the running application
     // despite being deprecated, this is also one of the few ways to get this information
     @Suppress("DEPRECATION")
@@ -125,7 +47,7 @@ object LaunchUtils {
     /**
      * Returns the directory that Geode/the game should base itself off of.
      */
-    fun getBaseDirectory(context: Context): File {
+    fun getBaseDirectory(context: Context, ignoreProfile: Boolean = false): File {
         // deprecated, but seems to be the best choice of directory (i forced mat to test it)
         // also, is getting the first item the correct choice here?? what do they mean
         @Suppress("DEPRECATION")
@@ -136,6 +58,14 @@ object LaunchUtils {
         val noMediaPath = File(dir, ".nomedia")
         noMediaPath.createNewFile()
 
+        val currentProfile = ProfileManager.get(context).getCurrentProfile()
+        if (currentProfile != null && !ignoreProfile) {
+            val profile = File(dir, "profiles/$currentProfile/")
+            profile.mkdirs()
+
+            return profile
+        }
+
         return dir
     }
 
@@ -143,19 +73,6 @@ object LaunchUtils {
         return File(getBaseDirectory(context), "save")
     }
 
-    @SuppressLint("DiscouragedPrivateApi")
-    fun addAssetsFromPackage(assetManager: AssetManager, packageInfo: PackageInfo) {
-        // this method is officially marked as deprecated but it is the only method we are allowed to reflect
-        // (the source recommends replacing with AssetManager.setApkAssets(ApkAssets[], boolean) lol)
-        val clazz = assetManager.javaClass
-        val aspMethod = clazz.getDeclaredMethod("addAssetPath", String::class.java)
-
-        aspMethod.invoke(assetManager, packageInfo.applicationInfo.sourceDir)
-        packageInfo.applicationInfo.splitSourceDirs?.forEach {
-            aspMethod.invoke(assetManager, it)
-        }
-    }
-
     private const val CRASH_INDICATOR_NAME = "lastSessionDidCrash"
 
     private fun getCrashDirectory(context: Context): File {
@@ -184,12 +101,17 @@ object LaunchUtils {
         return crashIndicatorFile.exists()
     }
 
-    enum class LauncherError {
+    enum class LauncherError : Serializable {
         LINKER_NEEDS_64BIT,
         LINKER_NEEDS_32BIT,
+        LINKER_FAILED_STL,
         LINKER_FAILED,
         GENERIC,
-        CRASHED
+        CRASHED;
+
+        fun isAbiFailure(): Boolean {
+            return this == LINKER_NEEDS_32BIT || this == LINKER_NEEDS_64BIT
+        }
     }
 
     const val LAUNCHER_KEY_RETURN_ERROR = "return_error"

app/src/main/java/com/geode/launcher/utils/PreferenceUtils.kt

@@ -8,7 +8,7 @@ import androidx.compose.runtime.MutableState
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.platform.LocalLifecycleOwner
+import androidx.lifecycle.compose.LocalLifecycleOwner
 import androidx.core.content.edit
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleEventObserver
@@ -20,8 +20,6 @@ import com.geode.launcher.BuildConfig
  */
 class PreferenceUtils(private val sharedPreferences: SharedPreferences) {
     companion object {
-        private const val FILE_KEY = "GeodeLauncherPreferencesFileKey"
-
         @Composable
         fun useBooleanPreference(preferenceKey: Key, lifecycleOwner: LifecycleOwner = LocalLifecycleOwner.current): MutableState<Boolean> {
             return usePreference(
@@ -70,11 +68,14 @@ class PreferenceUtils(private val sharedPreferences: SharedPreferences) {
             preferenceSet: (PreferenceUtils, Key, T) -> Unit
         ): MutableState<T> {
             val context = LocalContext.current
-            val sharedPreferences = context.getSharedPreferences(FILE_KEY, Context.MODE_PRIVATE)
+
+            val currentProfile = remember { ProfileManager.get(context).getCurrentFileKey() }
+            val sharedPreferences = context.getSharedPreferences(currentProfile, Context.MODE_PRIVATE)
 
             val preferences = get(sharedPreferences)
 
-            val preferenceValue = remember {
+            // inferring the type causes an internal compiler error. lol
+            val preferenceValue: MutableState<T> = remember {
                 val state = mutableStateOf(preferenceGet(preferences, preferenceKey))
                 object : MutableState<T> by state {
                     override var value: T
@@ -113,7 +114,8 @@ class PreferenceUtils(private val sharedPreferences: SharedPreferences) {
         }
 
         fun get(context: Context): PreferenceUtils {
-            val sharedPreferences = context.getSharedPreferences(FILE_KEY, Context.MODE_PRIVATE)
+            val currentFileKey = ProfileManager.get(context).getCurrentFileKey()
+            val sharedPreferences = context.getSharedPreferences(currentFileKey, Context.MODE_PRIVATE)
             return get(sharedPreferences)
         }
 
@@ -123,7 +125,6 @@ class PreferenceUtils(private val sharedPreferences: SharedPreferences) {
     }
 
     enum class Key {
-        LOAD_TESTING,
         LOAD_AUTOMATICALLY,
         UPDATE_AUTOMATICALLY,
         RELEASE_CHANNEL,
@@ -135,27 +136,42 @@ class PreferenceUtils(private val sharedPreferences: SharedPreferences) {
         LAST_DISMISSED_UPDATE,
         DISMISSED_GJ_UPDATE,
         LAUNCH_ARGUMENTS,
-        IGNORE_LOAD_FAILURE,
         LIMIT_ASPECT_RATIO,
-        DISPLAY_MODE
+        DISPLAY_MODE,
+        FORCE_HRR,
+        ENABLE_REDESIGN,
+        RELEASE_CHANNEL_TAG,
+        DEVELOPER_MODE,
+        CLEANUP_APKS,
+        CUSTOM_SYMBOL_LIST,
+        CUSTOM_ASPECT_RATIO,
+        SCREEN_ZOOM,
+        SCREEN_ZOOM_FIT,
+        LIMIT_FRAME_RATE
     }
 
     private fun defaultValueForBooleanKey(key: Key): Boolean {
         return when (key) {
-            Key.UPDATE_AUTOMATICALLY -> true
-            Key.RELEASE_CHANNEL -> BuildConfig.DEBUG
+            Key.UPDATE_AUTOMATICALLY, Key.FORCE_HRR -> true
+            Key.DEVELOPER_MODE -> BuildConfig.DEBUG
             else -> false
         }
     }
 
     private fun defaultValueForIntKey(key: Key) = when (key) {
         Key.DISPLAY_MODE -> if (this.getBoolean(Key.LIMIT_ASPECT_RATIO)) 1 else 0
+        Key.SCREEN_ZOOM -> 100
+        // people wanted a reset on nightly anyways, so this is a good excuse to do so
         else -> 0
     }
 
+    private fun defaultValueForStringKey(key: Key) = when (key) {
+        Key.CUSTOM_ASPECT_RATIO -> "16_9"
+        else -> null
+    }
+
     private fun keyToName(key: Key): String {
         return when (key) {
-            Key.LOAD_TESTING -> "PreferenceLoadTesting"
             Key.LOAD_AUTOMATICALLY -> "PreferenceLoadAutomatically"
             Key.UPDATE_AUTOMATICALLY -> "PreferenceUpdateAutomatically"
             Key.RELEASE_CHANNEL -> "PreferenceReleaseChannel"
@@ -167,9 +183,18 @@ class PreferenceUtils(private val sharedPreferences: SharedPreferences) {
             Key.LAST_DISMISSED_UPDATE -> "PreferenceLastDismissedUpdate"
             Key.DISMISSED_GJ_UPDATE -> "PreferenceDismissedGJUpdate"
             Key.LAUNCH_ARGUMENTS -> "PreferenceLaunchArguments"
-            Key.IGNORE_LOAD_FAILURE -> "PreferenceIgnoreLoadFailure"
             Key.LIMIT_ASPECT_RATIO -> "PreferenceLimitAspectRatio"
             Key.DISPLAY_MODE -> "PreferenceDisplayMode"
+            Key.FORCE_HRR -> "PreferenceForceHighRefreshRate"
+            Key.ENABLE_REDESIGN -> "PreferenceEnableRedesign"
+            Key.RELEASE_CHANNEL_TAG -> "PreferenceReleaseChannelTag"
+            Key.DEVELOPER_MODE -> "PreferenceDeveloperMode"
+            Key.CLEANUP_APKS -> "PreferenceCleanupPackages"
+            Key.CUSTOM_SYMBOL_LIST -> "PreferenceCustomSymbolList"
+            Key.CUSTOM_ASPECT_RATIO -> "PreferenceCustomAspectRatio"
+            Key.SCREEN_ZOOM -> "PreferenceScreenZoom"
+            Key.SCREEN_ZOOM_FIT -> "PreferenceScreenZoomFit"
+            Key.LIMIT_FRAME_RATE -> "PreferenceLimitFrameRate"
         }
     }
 
@@ -200,7 +225,7 @@ class PreferenceUtils(private val sharedPreferences: SharedPreferences) {
 
     fun getString(key: Key): String? {
         val keyName = keyToName(key)
-        return sharedPreferences.getString(keyName, null)
+        return sharedPreferences.getString(keyName, defaultValueForStringKey(key))
     }
 
     fun setString(key: Key, value: String?) {

app/src/main/java/com/geode/launcher/utils/ProfileManager.kt

@@ -0,0 +1,133 @@
+package com.geode.launcher.utils
+
+import android.content.Context
+import android.content.SharedPreferences
+import androidx.core.content.edit
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+
+private const val FILE_KEY = "GeodeLauncherPreferencesFileKey"
+private const val PROFILES_FILE_KEY = "GeodeLauncherProfiles"
+
+private const val PROFILE_LIST_SAVE_KEY = "profiles"
+private const val PROFILE_CURRENT_SAVE_KEY = "currentProfile"
+
+@Serializable
+data class Profile(val path: String, val name: String)
+
+class ProfileManager {
+    private val applicationContext: Context
+    private val preferences: SharedPreferences
+
+    companion object {
+        private lateinit var managerInstance: ProfileManager
+
+        fun get(context: Context): ProfileManager {
+            if (!Companion::managerInstance.isInitialized) {
+                val applicationContext = context.applicationContext
+
+                managerInstance = ProfileManager(applicationContext)
+            }
+
+            return managerInstance
+        }
+    }
+
+    constructor(applicationContext: Context) {
+        this.applicationContext = applicationContext
+        this.preferences = applicationContext.getSharedPreferences(PROFILES_FILE_KEY, Context.MODE_PRIVATE)
+
+        _storedProfiles.value = getProfiles()
+    }
+
+    private val _storedProfiles = MutableStateFlow<List<Profile>>(emptyList())
+    val storedProfiles = _storedProfiles.asStateFlow()
+
+    fun getCurrentProfile(): String? {
+        return preferences.getString(PROFILE_CURRENT_SAVE_KEY, null)
+            .takeUnless { it.isNullOrEmpty() }
+    }
+
+    fun getCurrentFileKey(): String {
+        val currentProfile = getCurrentProfile()
+            ?: return FILE_KEY
+
+        return "${FILE_KEY}_${currentProfile}"
+    }
+
+    fun getProfile(path: String): Profile? {
+        val profilesSet = preferences.getStringSet(PROFILE_LIST_SAVE_KEY, null)
+        return profilesSet?.firstNotNullOfOrNull {
+            Json.decodeFromString<Profile>(it).takeIf { it.path == path }
+        }
+    }
+
+    /**
+     * Store a profile into the save, removing any duplicate profiles beforehand
+     */
+    fun storeProfile(profile: Profile) {
+        val profilesSet = preferences.getStringSet(PROFILE_LIST_SAVE_KEY, null) ?: emptySet<String>()
+
+        val removedList = profilesSet.filterTo(LinkedHashSet()) {
+            val saveProfile = Json.decodeFromString<Profile>(it)
+            saveProfile.path != profile.path
+        }
+        removedList.add(Json.encodeToString(profile))
+
+        preferences.edit {
+            putStringSet(PROFILE_LIST_SAVE_KEY, removedList)
+        }
+
+        _storedProfiles.value = getProfiles()
+    }
+
+    fun deleteProfile(path: String) {
+        val profilesSet = preferences.getStringSet(PROFILE_LIST_SAVE_KEY, null) ?: emptySet<String>()
+
+        val removedList = profilesSet.filterTo(LinkedHashSet()) {
+            val saveProfile = Json.decodeFromString<Profile>(it)
+            saveProfile.path != path
+        }
+
+        preferences.edit {
+            putStringSet(PROFILE_LIST_SAVE_KEY, removedList)
+        }
+
+        _storedProfiles.value = getProfiles()
+    }
+
+    fun deleteProfiles(paths: List<String>) {
+        val profilesSet = preferences.getStringSet(PROFILE_LIST_SAVE_KEY, null) ?: emptySet<String>()
+
+        val removedList = profilesSet.filterTo(LinkedHashSet()) {
+            val saveProfile = Json.decodeFromString<Profile>(it)
+            !paths.contains(saveProfile.path)
+        }
+
+        preferences.edit(commit = true) {
+            putStringSet(PROFILE_LIST_SAVE_KEY, removedList)
+        }
+
+        _storedProfiles.value = getProfiles()
+    }
+
+    fun setCurrentProfile(profile: String?) {
+        preferences.edit(commit = true) {
+            if (profile.isNullOrEmpty()) {
+                remove(PROFILE_CURRENT_SAVE_KEY)
+            } else {
+                putString(PROFILE_CURRENT_SAVE_KEY, profile)
+            }
+        }
+    }
+
+    fun getProfiles(): List<Profile> {
+        val profilesSet = preferences.getStringSet(PROFILE_LIST_SAVE_KEY, null) ?: emptySet<String>()
+
+        return profilesSet.map {
+            Json.decodeFromString<Profile>(it)
+        }
+    }
+}

app/src/main/java/com/geode/launcher/utils/useCountdownTimer.kt

@@ -1,7 +1,7 @@
 package com.geode.launcher.utils
 
 import androidx.compose.runtime.*
-import androidx.compose.ui.platform.LocalLifecycleOwner
+import androidx.lifecycle.compose.LocalLifecycleOwner
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleEventObserver
 import androidx.lifecycle.LifecycleOwner

app/src/main/java/org/cocos2dx/lib/Cocos2dxAccelerometer.kt

@@ -0,0 +1,102 @@
+/****************************************************************************
+Copyright (c) 2010-2011 cocos2d-x.org
+
+http://www.cocos2d-x.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+ ****************************************************************************/
+package org.cocos2dx.lib
+
+import android.content.Context
+import android.content.res.Configuration
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+import android.os.Build
+import android.view.Surface
+import android.view.WindowManager
+import java.lang.ref.WeakReference
+import kotlin.math.roundToInt
+
+class Cocos2dxAccelerometer : SensorEventListener {
+    companion object {
+        @JvmStatic
+        external fun onSensorChanged(pX: Float, pY: Float, pZ: Float, pTimestamp: Long)
+    }
+
+    constructor(context: Context) {
+        mContext = WeakReference(context)
+        mSensorManager = context.getSystemService(Context.SENSOR_SERVICE) as SensorManager
+        mAccelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
+        val display = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            context.display
+        } else {
+            @Suppress("DEPRECATION")
+            (context.getSystemService(Context.WINDOW_SERVICE) as WindowManager).defaultDisplay
+        }
+        this.mNaturalOrientation = display.rotation
+    }
+
+    private val mContext: WeakReference<Context>
+    private val mSensorManager: SensorManager
+    private val mAccelerometer: Sensor?
+    private val mNaturalOrientation: Int
+
+    fun enable() {
+        this.mSensorManager.registerListener(this, this.mAccelerometer, SensorManager.SENSOR_DELAY_GAME)
+    }
+
+    fun setInterval(interval: Float) {
+        this.mSensorManager.registerListener(this, this.mAccelerometer, (interval * 100000).roundToInt())
+    }
+
+    fun disable() {
+        this.mSensorManager.unregisterListener(this)
+    }
+
+    override fun onSensorChanged(pSensorEvent: SensorEvent) {
+        if (pSensorEvent.sensor.type != Sensor.TYPE_ACCELEROMETER) {
+            return
+        }
+
+        var (x, y, z) = pSensorEvent.values
+
+        /*
+         * Because the axes are not swapped when the device's screen orientation
+         * changes. So we should swap it here. In tablets such as Motorola Xoom,
+         * the default orientation is landscape, so should consider this.
+         */
+        val orientation = this.mContext.get()!!.resources.configuration.orientation
+
+        if ((orientation == Configuration.ORIENTATION_LANDSCAPE) && (this.mNaturalOrientation != Surface.ROTATION_0)) {
+            val tmp = x
+            x = -y
+            y = tmp
+        } else if ((orientation == Configuration.ORIENTATION_PORTRAIT) && (this.mNaturalOrientation != Surface.ROTATION_0)) {
+            val tmp = x
+            x = y
+            y = -tmp
+        }
+
+        Cocos2dxGLSurfaceView.queueAccelerometer(x, y, z, pSensorEvent.timestamp)
+    }
+
+    override fun onAccuracyChanged(pSensor: Sensor, pAccuracy: Int) {}
+}

app/src/main/java/org/cocos2dx/lib/Cocos2dxGLSurfaceView.kt

@@ -1,19 +1,24 @@
 package org.cocos2dx.lib
 
+import android.app.Activity
 import android.content.Context
 import android.opengl.GLSurfaceView
+import android.os.Build
 import android.os.Handler
 import android.os.Looper
 import android.os.Message
 import android.util.Log
 import android.view.KeyEvent
 import android.view.MotionEvent
+import android.view.Surface
 import android.view.inputmethod.InputMethodManager
+import androidx.annotation.RequiresApi
 import com.customRobTop.BaseRobTopActivity
 import com.geode.launcher.utils.GeodeUtils
 
 private const val HANDLER_OPEN_IME_KEYBOARD = 2
 private const val HANDLER_CLOSE_IME_KEYBOARD = 3
+private const val MS_TO_NS = 1_000_000
 
 class Cocos2dxGLSurfaceView(context: Context) : GLSurfaceView(context) {
     companion object {
@@ -35,6 +40,11 @@ class Cocos2dxGLSurfaceView(context: Context) : GLSurfaceView(context) {
             msg.what = HANDLER_CLOSE_IME_KEYBOARD
             handler.sendMessage(msg)
         }
+
+        fun queueAccelerometer(x: Float, y: Float, z: Float, timestamp: Long) =
+            cocos2dxGLSurfaceView.queueEvent {
+                Cocos2dxAccelerometer.onSensorChanged(x, y, z, timestamp)
+            }
     }
 
     private lateinit var cocos2dxRenderer: Cocos2dxRenderer
@@ -44,6 +54,8 @@ class Cocos2dxGLSurfaceView(context: Context) : GLSurfaceView(context) {
             cocos2dxRenderer.sendResizeEvents = value
         }
 
+    var sendTimestampEvents = false
+
     var cocos2dxEditText: Cocos2dxEditText? = null
         set(value) {
             field = value
@@ -56,9 +68,7 @@ class Cocos2dxGLSurfaceView(context: Context) : GLSurfaceView(context) {
     fun initView() {
         setEGLContextClientVersion(2)
         isFocusableInTouchMode = true
-//        if (Build.VERSION.SDK_INT >= 11) {
         preserveEGLContextOnPause = true
-//        }
         cocos2dxGLSurfaceView = this
         cocos2dxTextInputWrapper = Cocos2dxTextInputWrapper(this)
         Cocos2dxGLSurfaceView.handler = object : Handler(Looper.getMainLooper()) {
@@ -109,13 +119,33 @@ class Cocos2dxGLSurfaceView(context: Context) : GLSurfaceView(context) {
         }
     }
 
+    @RequiresApi(Build.VERSION_CODES.R)
+    fun updateRefreshRate() {
+        val chosenDisplay = display.supportedModes?.maxByOrNull { it.refreshRate }
+        if (chosenDisplay == null) {
+            println("updateRefreshRate failed to find a display to maximize refresh rate...")
+            return
+        }
+
+        val chosenRefreshRate = chosenDisplay.refreshRate
+
+        println("updateRefreshRate: selecting refresh rate of ${chosenDisplay.refreshRate} (display ${chosenDisplay.modeId})")
+
+        holder.surface.setFrameRate(chosenRefreshRate, Surface.FRAME_RATE_COMPATIBILITY_DEFAULT)
+        if (isAttachedToWindow) {
+            (context as Activity).window.attributes.preferredRefreshRate = chosenRefreshRate
+        }
+    }
+
     override fun onPause() {
         queueEvent { cocos2dxRenderer.handleOnPause() }
+        renderMode = RENDERMODE_WHEN_DIRTY
         super.onPause()
     }
 
     override fun onResume() {
         super.onResume()
+        renderMode = RENDERMODE_CONTINUOUSLY
         queueEvent { cocos2dxRenderer.handleOnResume() }
     }
 
@@ -124,6 +154,9 @@ class Cocos2dxGLSurfaceView(context: Context) : GLSurfaceView(context) {
         val ids = IntArray(pointerNumber)
         val xs = FloatArray(pointerNumber)
         val ys = FloatArray(pointerNumber)
+        val timestamp = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
+            motionEvent.eventTimeNanos else motionEvent.eventTime * MS_TO_NS
+
         for (i in 0 until pointerNumber) {
             ids[i] = motionEvent.getPointerId(i)
             xs[i] = motionEvent.getX(i)
@@ -135,11 +168,10 @@ class Cocos2dxGLSurfaceView(context: Context) : GLSurfaceView(context) {
                 val xDown = xs[0]
                 val f = ys[0]
                 queueEvent {
-                    cocos2dxRenderer.handleActionDown(
-                        idDown,
-                        xDown,
-                        f
-                    )
+                    if (sendTimestampEvents)
+                        GeodeUtils.setNextInputTimestamp(timestamp)
+
+                    cocos2dxRenderer.handleActionDown(idDown, xDown, f)
                 }
                 true
             }
@@ -147,26 +179,29 @@ class Cocos2dxGLSurfaceView(context: Context) : GLSurfaceView(context) {
                 val idUp = motionEvent.getPointerId(0)
                 val f2 = xs[0]
                 val f3 = ys[0]
-                queueEvent { cocos2dxRenderer.handleActionUp(idUp, f2, f3) }
+                queueEvent {
+                    if (sendTimestampEvents)
+                        GeodeUtils.setNextInputTimestamp(timestamp)
+
+                    cocos2dxRenderer.handleActionUp(idUp, f2, f3)
+                }
                 true
             }
             MotionEvent.ACTION_MOVE -> {
                 queueEvent {
-                    cocos2dxRenderer.handleActionMove(
-                        ids,
-                        xs,
-                        ys
-                    )
+                    if (sendTimestampEvents)
+                        GeodeUtils.setNextInputTimestamp(timestamp)
+
+                    cocos2dxRenderer.handleActionMove(ids, xs, ys)
                 }
                 true
             }
             MotionEvent.ACTION_CANCEL -> {
                 queueEvent {
-                    cocos2dxRenderer.handleActionCancel(
-                        ids,
-                        xs,
-                        ys
-                    )
+                    if (sendTimestampEvents)
+                        GeodeUtils.setNextInputTimestamp(timestamp)
+
+                    cocos2dxRenderer.handleActionCancel(ids, xs, ys)
                 }
                 true
             }
@@ -176,11 +211,10 @@ class Cocos2dxGLSurfaceView(context: Context) : GLSurfaceView(context) {
                 val xPointerDown = motionEvent.getX(indexPointerDown)
                 val y = motionEvent.getY(indexPointerDown)
                 queueEvent {
-                    cocos2dxRenderer.handleActionDown(
-                        idPointerDown,
-                        xPointerDown,
-                        y
-                    )
+                    if (sendTimestampEvents)
+                        GeodeUtils.setNextInputTimestamp(timestamp)
+
+                    cocos2dxRenderer.handleActionDown(idPointerDown, xPointerDown, y)
                 }
                 true
             }
@@ -190,11 +224,10 @@ class Cocos2dxGLSurfaceView(context: Context) : GLSurfaceView(context) {
                 val xPointerUp = motionEvent.getX(indexPointUp)
                 val y2 = motionEvent.getY(indexPointUp)
                 queueEvent {
-                    cocos2dxRenderer.handleActionUp(
-                        idPointerUp,
-                        xPointerUp,
-                        y2
-                    )
+                    if (sendTimestampEvents)
+                        GeodeUtils.setNextInputTimestamp(timestamp)
+
+                    cocos2dxRenderer.handleActionUp(idPointerUp, xPointerUp, y2)
                 }
                 true
             }
@@ -242,6 +275,9 @@ class Cocos2dxGLSurfaceView(context: Context) : GLSurfaceView(context) {
                 }
 
                 queueEvent {
+                    if (sendTimestampEvents)
+                        GeodeUtils.setNextInputTimestamp(event.eventTime * MS_TO_NS)
+
                     GeodeUtils.nativeKeyDown(keyCode, event.modifiers, event.repeatCount != 0)
                 }
                 true
@@ -264,6 +300,9 @@ class Cocos2dxGLSurfaceView(context: Context) : GLSurfaceView(context) {
                 }
 
                 queueEvent {
+                    if (sendTimestampEvents)
+                        GeodeUtils.setNextInputTimestamp(event.eventTime * MS_TO_NS)
+
                     GeodeUtils.nativeKeyUp(keyCode, event.modifiers)
                 }
 
@@ -280,8 +319,13 @@ class Cocos2dxGLSurfaceView(context: Context) : GLSurfaceView(context) {
         if (event?.action == MotionEvent.ACTION_SCROLL) {
             val scrollX = event.getAxisValue(MotionEvent.AXIS_HSCROLL)
             val scrollY = event.getAxisValue(MotionEvent.AXIS_VSCROLL)
+            val timestamp = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
+                event.eventTimeNanos else event.eventTime * MS_TO_NS
 
             queueEvent {
+                if (sendTimestampEvents)
+                    GeodeUtils.setNextInputTimestamp(timestamp)
+
                 GeodeUtils.nativeActionScroll(scrollX, scrollY)
             }
 

app/src/main/java/org/cocos2dx/lib/Cocos2dxHelper.kt

@@ -2,6 +2,7 @@ package org.cocos2dx.lib
 
 import android.content.Context
 import android.content.pm.ApplicationInfo
+import android.content.res.AssetManager
 import android.os.Process
 import com.customRobTop.BaseRobTopActivity
 import com.geode.launcher.utils.LaunchUtils
@@ -11,9 +12,9 @@ import com.geode.launcher.utils.LaunchUtils
 object Cocos2dxHelper {
 //    private val sCocos2dMusic: Cocos2dxMusic? = null
 //    private val sCocos2dSound: Cocos2dxSound? = null
-//    private val sAssetManager: AssetManager? = null
-//    private val sCocos2dxAccelerometer: Cocos2dxAccelerometer? = null
-//    private val sAccelerometerEnabled = false
+    private var sAssetManager: AssetManager? = null
+    private var sCocos2dxAccelerometer: Cocos2dxAccelerometer? = null
+    private var sAccelerometerEnabled = false
     private var packageName: String? = null
     private var fileDirectory: String? = null
 
@@ -36,6 +37,40 @@ object Cocos2dxHelper {
         Process.killProcess(Process.myPid())
     }
 
+    @JvmStatic
+    fun getAssetManager(): AssetManager? {
+        return sAssetManager
+    }
+
+    @JvmStatic
+    fun enableAccelerometer() {
+        sAccelerometerEnabled = true
+        sCocos2dxAccelerometer?.enable()
+    }
+
+    @JvmStatic
+    fun setAccelerometerInterval(interval: Float) {
+        sCocos2dxAccelerometer?.setInterval(interval)
+    }
+
+    @JvmStatic
+    fun disableAccelerometer() {
+        sAccelerometerEnabled = false
+        sCocos2dxAccelerometer?.disable()
+    }
+
+    fun onResume() {
+        if (sAccelerometerEnabled) {
+            sCocos2dxAccelerometer?.enable()
+        }
+    }
+
+    fun onPause() {
+        if (sAccelerometerEnabled) {
+            sCocos2dxAccelerometer?.disable()
+        }
+    }
+
     @JvmStatic
     fun getDPI(): Int {
         return BaseRobTopActivity.me.get()?.resources?.configuration?.densityDpi ?: -1
@@ -52,14 +87,14 @@ object Cocos2dxHelper {
         this.cocos2dxHelperListener = cocos2dxHelperListener
         packageName = applicationInfo.packageName
         fileDirectory = LaunchUtils.getSaveDirectory(context).absolutePath
-//        Cocos2dxHelper.sCocos2dxAccelerometer = Cocos2dxAccelerometer(pContext)
+        sCocos2dxAccelerometer = Cocos2dxAccelerometer(context)
 //        Cocos2dxHelper.sCocos2dMusic = Cocos2dxMusic(pContext)
 //        var simultaneousStreams: Int = Cocos2dxSound.MAX_SIMULTANEOUS_STREAMS_DEFAULT
 //        if (Cocos2dxHelper.getDeviceModel().indexOf("GT-I9100") !== -1) {
 //            simultaneousStreams = Cocos2dxSound.MAX_SIMULTANEOUS_STREAMS_I9100
 //        }
 //        Cocos2dxHelper.sCocos2dSound = Cocos2dxSound(pContext, simultaneousStreams)
-//        Cocos2dxHelper.sAssetManager = pContext.getAssets()
+        sAssetManager = context.assets
         Cocos2dxBitmap.setContext(context)
 //            Cocos2dxETCLoader.setContext(pContext)
     }

app/src/main/java/org/cocos2dx/lib/Cocos2dxRenderer.kt

@@ -1,11 +1,15 @@
 package org.cocos2dx.lib
 
 import android.opengl.GLSurfaceView
+import android.os.Build
 import javax.microedition.khronos.egl.EGLConfig
 import javax.microedition.khronos.opengles.GL10
 
+private const val NANOSECONDS_PER_SECOND = 1000000000L
+private const val NANOSECONDS_PER_MICROSECOND = 1000000L
+
 @Suppress("unused", "KotlinJniMissingFunction")
-class Cocos2dxRenderer : GLSurfaceView.Renderer {
+class Cocos2dxRenderer(private var handler: Cocos2dxGLSurfaceView) : GLSurfaceView.Renderer {
     companion object {
         @JvmStatic
         fun setAnimationInterval(@Suppress("UNUSED_PARAMETER") animationInterval: Double) {
@@ -60,6 +64,12 @@ class Cocos2dxRenderer : GLSurfaceView.Renderer {
     private var screenWidth = 0
     private var screenHeight = 0
     var sendResizeEvents = false
+    var setFrameRate = false
+    private var mAnimationInterval: Long? = null
+
+    fun limitFrameRate(rate: Int) {
+        mAnimationInterval = NANOSECONDS_PER_SECOND/rate
+    }
 
     fun setScreenWidthAndHeight(surfaceWidth: Int, surfaceHeight: Int) {
         screenWidth = surfaceWidth
@@ -71,10 +81,32 @@ class Cocos2dxRenderer : GLSurfaceView.Renderer {
         lastTickInNanoSeconds = System.nanoTime()
     }
 
-    override fun onSurfaceChanged(gl10: GL10?, width: Int, height: Int) {}
+    override fun onSurfaceChanged(gl10: GL10?, width: Int, height: Int) {
+        if (setFrameRate && Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            handler.updateRefreshRate()
+        }
+
+        println("renderer surfaceChanged: ${width}x${height}@${handler.display.refreshRate}fps")
+    }
 
     override fun onDrawFrame(gl: GL10?) {
-        nativeRender()
+        val animationInterval = mAnimationInterval
+        if (animationInterval == null) {
+            nativeRender()
+        } else {
+            nativeRender()
+
+            val now = System.nanoTime()
+            val interval = now - this.lastTickInNanoSeconds
+
+            if (interval < animationInterval) {
+                try {
+                    Thread.sleep((animationInterval - interval) / NANOSECONDS_PER_MICROSECOND)
+                } catch (e: Exception) {}
+            }
+
+            lastTickInNanoSeconds = System.nanoTime()
+        }
     }
 
     fun handleActionDown(id: Int, x: Float, y: Float) {

app/src/main/java/org/cocos2dx/lib/Cocos2dxTypefaces.kt

@@ -10,8 +10,9 @@ object Cocos2dxTypefaces {
 
     @Synchronized
     operator fun get(pContext: Context, pAssetName: String): Typeface? {
-        var typeface: Typeface?
-        var typeface2: Typeface
+        val typeface: Typeface?
+        val typeface2: Typeface
+
         synchronized(Cocos2dxTypefaces::class.java) {
             if (!typefaceCache.containsKey(pAssetName)) {
                 typeface2 = if (pAssetName.startsWith("/")) {

app/src/main/java/org/fmod/MediaCodec.kt

@@ -11,18 +11,24 @@ import java.io.IOException
 import java.nio.ByteBuffer
 
 class MediaCodec {
-    private var channelCount = 0
+    // these variables require getX functions for ndk access
+    var channelCount = 0
+        private set
 
-    var mCodecPtr = 0L
+    var length = 0L
+        private set
+
+    var sampleRate = 0
+        private set
+
+    private var mCodecPtr = 0L
     private var mCurrentOutputBufferIndex = -1
     private var mDecoder: MediaCodec? = null
     private var mExtractor: MediaExtractor? = null
     private var mInputBuffers: Array<ByteBuffer>? = null
     private var mInputFinished = false
-    private var length = 0L
     private var mOutputBuffers: Array<ByteBuffer>? = null
     private var mOutputFinished = false
-    private var sampleRate = 0
 
     fun init(codecPtr: Long): Boolean {
         mCodecPtr = codecPtr

app/src/main/res/drawable/geode_monochrome.xml

@@ -0,0 +1,18 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:aapt="http://schemas.android.com/aapt"
+    android:width="96dp"
+    android:height="96dp"
+    android:viewportWidth="696"
+    android:viewportHeight="698"
+    android:tint="?attr/colorControlNormal">
+  <path
+      android:pathData="M393.08,24.42L372.88,9C358.19,-2.22 337.81,-2.22 323.12,9L16.94,242.81C3.28,253.24 -2.42,271.09 2.66,287.51L120.41,668.43C125.72,685.61 141.6,697.33 159.58,697.33H536.42C554.4,697.33 570.28,685.61 575.59,668.43L693.34,287.51C698.42,271.09 692.72,253.24 679.06,242.81L650.84,221.26L618.37,323.39L529.2,613.39C525.71,624.72 515.24,632.46 503.39,632.46H190.61C178.76,632.46 168.29,624.72 164.8,613.39L67.2,295.97C63.88,285.19 67.62,273.49 76.56,266.62L330.56,71.62C331.58,70.84 332.64,70.14 333.74,69.52L393.08,24.42Z"
+      android:fillType="evenOdd"
+      android:fillColor="@android:color/white">
+  </path>
+  <path
+      android:pathData="M336.61,143.26C344.51,137.21 355.49,137.21 363.39,143.26L552.8,288.49C560.1,294.09 563.14,303.63 560.44,312.42L487.62,548.92C484.78,558.15 476.25,564.45 466.59,564.45H233.41C223.75,564.45 215.22,558.15 212.38,548.92L199.93,508.5H261.68C262.39,508.65 263.13,508.72 263.89,508.72H432.11C436.96,508.72 441.24,505.55 442.64,500.9L495.14,326.98C496.45,322.64 494.96,317.93 491.39,315.14L354.78,208.3C350.8,205.19 345.2,205.19 341.22,208.3L215.93,306.29L152.15,353.31L139.56,312.42C136.86,303.63 139.9,294.09 147.2,288.49L336.61,143.26Z"
+      android:fillType="evenOdd"
+      android:fillColor="@android:color/white">
+  </path>
+</vector>

app/src/main/res/drawable/icon_data_object.xml

@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960"
+    android:tint="?attr/colorControlNormal">
+  <path
+      android:fillColor="@android:color/white"
+      android:pathData="M560,800L560,720L680,720Q697,720 708.5,708.5Q720,697 720,680L720,600Q720,562 742,531Q764,500 800,487L800,473Q764,460 742,429Q720,398 720,360L720,280Q720,263 708.5,251.5Q697,240 680,240L560,240L560,160L680,160Q730,160 765,195Q800,230 800,280L800,360Q800,377 811.5,388.5Q823,400 840,400L880,400L880,560L840,560Q823,560 811.5,571.5Q800,583 800,600L800,680Q800,730 765,765Q730,800 680,800L560,800ZM280,800Q230,800 195,765Q160,730 160,680L160,600Q160,583 148.5,571.5Q137,560 120,560L80,560L80,400L120,400Q137,400 148.5,388.5Q160,377 160,360L160,280Q160,230 195,195Q230,160 280,160L400,160L400,240L280,240Q263,240 251.5,251.5Q240,263 240,280L240,360Q240,398 218,429Q196,460 160,473L160,487Q196,500 218,531Q240,562 240,600L240,680Q240,697 251.5,708.5Q263,720 280,720L400,720L400,800L280,800Z"/>
+</vector>

app/src/main/res/drawable/icon_link.xml

@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960"
+    android:tint="?attr/colorControlNormal">
+  <path
+      android:fillColor="@android:color/white"
+      android:pathData="M440,680L280,680Q197,680 138.5,621.5Q80,563 80,480Q80,397 138.5,338.5Q197,280 280,280L440,280L440,360L280,360Q230,360 195,395Q160,430 160,480Q160,530 195,565Q230,600 280,600L440,600L440,680ZM320,520L320,440L640,440L640,520L320,520ZM520,680L520,600L680,600Q730,600 765,565Q800,530 800,480Q800,430 765,395Q730,360 680,360L520,360L520,280L680,280Q763,280 821.5,338.5Q880,397 880,480Q880,563 821.5,621.5Q763,680 680,680L520,680Z"/>
+</vector>

app/src/main/res/drawable/icon_person.xml

@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960"
+    android:tint="?attr/colorControlNormal">
+  <path
+      android:fillColor="@android:color/white"
+      android:pathData="M480,480Q414,480 367,433Q320,386 320,320Q320,254 367,207Q414,160 480,160Q546,160 593,207Q640,254 640,320Q640,386 593,433Q546,480 480,480ZM160,800L160,688Q160,654 177.5,625.5Q195,597 224,582Q286,551 350,535.5Q414,520 480,520Q546,520 610,535.5Q674,551 736,582Q765,597 782.5,625.5Q800,654 800,688L800,800L160,800ZM240,720L720,720L720,688Q720,677 714.5,668Q709,659 700,654Q646,627 591,613.5Q536,600 480,600Q424,600 369,613.5Q314,627 260,654Q251,659 245.5,668Q240,677 240,688L240,720ZM480,400Q513,400 536.5,376.5Q560,353 560,320Q560,287 536.5,263.5Q513,240 480,240Q447,240 423.5,263.5Q400,287 400,320Q400,353 423.5,376.5Q447,400 480,400ZM480,320Q480,320 480,320Q480,320 480,320Q480,320 480,320Q480,320 480,320Q480,320 480,320Q480,320 480,320Q480,320 480,320Q480,320 480,320ZM480,720L480,720Q480,720 480,720Q480,720 480,720Q480,720 480,720Q480,720 480,720Q480,720 480,720Q480,720 480,720Q480,720 480,720Q480,720 480,720L480,720Z"/>
+</vector>

app/src/main/res/drawable/icon_person_add.xml

@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960"
+    android:tint="?attr/colorControlNormal">
+  <path
+      android:fillColor="@android:color/white"
+      android:pathData="M720,560L720,440L600,440L600,360L720,360L720,240L800,240L800,360L920,360L920,440L800,440L800,560L720,560ZM360,480Q294,480 247,433Q200,386 200,320Q200,254 247,207Q294,160 360,160Q426,160 473,207Q520,254 520,320Q520,386 473,433Q426,480 360,480ZM40,800L40,688Q40,654 57.5,625.5Q75,597 104,582Q166,551 230,535.5Q294,520 360,520Q426,520 490,535.5Q554,551 616,582Q645,597 662.5,625.5Q680,654 680,688L680,800L40,800ZM120,720L600,720L600,688Q600,677 594.5,668Q589,659 580,654Q526,627 471,613.5Q416,600 360,600Q304,600 249,613.5Q194,627 140,654Q131,659 125.5,668Q120,677 120,688L120,720ZM360,400Q393,400 416.5,376.5Q440,353 440,320Q440,287 416.5,263.5Q393,240 360,240Q327,240 303.5,263.5Q280,287 280,320Q280,353 303.5,376.5Q327,400 360,400ZM360,320Q360,320 360,320Q360,320 360,320Q360,320 360,320Q360,320 360,320Q360,320 360,320Q360,320 360,320Q360,320 360,320Q360,320 360,320ZM360,720L360,720Q360,720 360,720Q360,720 360,720Q360,720 360,720Q360,720 360,720Q360,720 360,720Q360,720 360,720Q360,720 360,720Q360,720 360,720L360,720Z"/>
+</vector>

app/src/main/res/drawable/icon_question_mark.xml

@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960"
+    android:tint="?attr/colorControlNormal">
+  <path
+      android:fillColor="@android:color/white"
+      android:pathData="M424,640Q424,559 438.5,523.5Q453,488 500,446Q541,410 562.5,383.5Q584,357 584,323Q584,282 556.5,255Q529,228 480,228Q429,228 402.5,259Q376,290 365,322L262,278Q283,214 339,167Q395,120 480,120Q585,120 641.5,178.5Q698,237 698,319Q698,369 676.5,404.5Q655,440 609,485Q560,532 549.5,556.5Q539,581 539,640L424,640ZM480,880Q447,880 423.5,856.5Q400,833 400,800Q400,767 423.5,743.5Q447,720 480,720Q513,720 536.5,743.5Q560,767 560,800Q560,833 536.5,856.5Q513,880 480,880Z"/>
+</vector>

app/src/main/res/drawable/icon_remove.xml

@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960"
+    android:tint="?attr/colorControlNormal">
+  <path
+      android:fillColor="@android:color/white"
+      android:pathData="M200,520L200,440L760,440L760,520L200,520Z"/>
+</vector>

app/src/main/res/drawable/icon_resume.xml

@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960"
+    android:tint="?attr/colorControlNormal">
+  <path
+      android:fillColor="@android:color/white"
+      android:pathData="M240,720L240,240L320,240L320,720L240,720ZM400,720L800,480L400,240L400,720ZM480,579L480,381L645,480L480,579ZM480,480L480,480L480,480Z"/>
+</vector>

app/src/main/res/drawable/icon_undo.xml

@@ -0,0 +1,11 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960"
+    android:tint="?attr/colorControlNormal"
+    android:autoMirrored="true">
+  <path
+      android:fillColor="@android:color/white"
+      android:pathData="M280,760L280,680L564,680Q627,680 673.5,640Q720,600 720,540Q720,480 673.5,440Q627,400 564,400L312,400L416,504L360,560L160,360L360,160L416,216L312,320L564,320Q661,320 730.5,383Q800,446 800,540Q800,634 730.5,697Q661,760 564,760L280,760Z"/>
+</vector>

app/src/main/res/drawable/xps_icon.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@mipmap/ic_launcher_background"/>
+    <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
+</adaptive-icon>

app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml

@@ -1,6 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@color/ic_launcher_background"/>
-    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
-    <monochrome android:drawable="@drawable/ic_launcher_monochrome" />
+    <background android:drawable="@mipmap/ic_launcher_background"/>
+    <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
 </adaptive-icon>

app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@mipmap/ic_launcher_background"/>
+    <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
+</adaptive-icon>

app/src/main/res/values/strings.xml

@@ -1,20 +1,24 @@
 <resources>
-    <string name="app_name" translatable="false">Geode</string>
+    <string name="app_name" translatable="false">XPS: Geode Edition</string>
     <string name="no_activity_found">No activity found for this action.</string>
 
     <!-- MainActivity strings -->
-    <string name="game_not_found">Geometry Dash was not found.</string>
+    <string name="game_not_found">XPS 2.2 isn\'t installed</string>
     <string name="launcher_launch">Launch</string>
     <string name="launcher_settings">Settings</string>
     <string name="launcher_download">Download</string>
+    <string name="launcher_install">Install</string>
     <string name="launcher_title">Geode</string>
     <string name="launcher_logo_alt">geode logo</string>
     <string name="launcher_launch_icon_alt">play icon</string>
     <string name="launcher_download_icon_alt">download icon</string>
+    <string name="launcher_download_game">Download Game</string>
+    <string name="launcher_download_32bit">Download the 32-bit version of launcher.</string>
+    <string name="launcher_download_universal">Download the non 32-bit version of launcher.</string>
     <string name="launcher_settings_icon_alt">settings icon</string>
     <string name="launcher_retry_icon_alt">retry icon</string>
     <string name="geode_download_title">Geode is not installed.</string>
-    <string name="game_outdated">A Geometry Dash update is required.</string>
+    <string name="game_outdated">A XPS update is required.\nYou currently have update %1$s.</string>
     <string name="geode_download_description">Geode is downloading. Please wait.</string>
     <plurals name="automatically_load_countdown">
         <item quantity="one">Automatically launching game in %1$d second.</item>
@@ -24,13 +28,22 @@
     <string name="launcher_error_icon_alt">error</string>
     <string name="launcher_unsupported_version_title">Unsupported version</string>
     <string name="launcher_outdated_version_description">
-        The current version of Geometry Dash is not compatible with the version supported by the launcher (%2$s). You must update Geometry Dash to fix this.\nLaunch will continue, but crashes may occur!
+        The current version of XPS is not compatible with the version supported by the launcher (%2$s). You must update XPS to fix this.\nLaunch will continue, but crashes may occur!
     </string>
     <string name="launcher_unsupported_version_description">
-        The current version of Geometry Dash is not compatible with the version supported by the launcher. A launcher update is required to fix this.\nLaunch will continue, but crashes may occur!
+        The current version of XPS is not compatible with the version supported by the launcher. A launcher update is required to fix this.\nLaunch will continue, but crashes may occur!
     </string>
+
+    <string name="launcher_game_update_required_short">A XPS update is required.</string>
+    <string name="launcher_game_update_required">The currently installed version of XPS is no longer supported. Please update XPS to continue receiving Geode updates.</string>
+
     <string name="launcher_update_available">A new launcher update is available!</string>
     <string name="launcher_update_dismiss">Dismiss</string>
+    <string name="launcher_update_view">View</string>
+    <string name="launcher_update_external_link">View in browser</string>
+    <string name="launcher_update_name">Geode Launcher v%1$s</string>
+    <string name="launcher_update_changelog">Changelog</string>
+    <string name="launcher_update_released">Released %1$s</string>
     <string name="safe_mode_enable_title">Enable safe mode?</string>
     <string name="safe_mode_enable_description">Safe mode disables loading of all mods, allowing one to remove problematic mods or diagnose crashes. If you\'re not experiencing issues with Geode, you should probably not be using safe mode.</string>
     <string name="launcher_failed_to_load">Geode failed to load.</string>
@@ -42,7 +55,28 @@
     <string name="launcher_error_copy">Copy details</string>
     <string name="launcher_error_export_crash">Share crash</string>
     <string name="launcher_error_export_missing">No crash dump was found!</string>
-    <string name="launcher_error_device_info">Android %2$s, %1$s</string>
+    <string name="launcher_error_device_info">Android %2$s, %1$s (%5$s)\nGD %4$s, Geode %3$s + v%6$s</string>
+
+    <string name="launcher_notification_settings">Launcher Settings</string>
+    <string name="launcher_notification_update_failed">Failed to update Geode.</string>
+    <string name="launcher_notification_update_success">Geode updated!</string>
+    <string name="launcher_notification_compatibility">Unsupported XPS version.</string>
+    <string name="launcher_notification_compatibility_description">An update is required to receive Geode updates.</string>
+    <string name="launcher_notification_update_cta">Tap for more information.</string>
+
+    <string name="launcher_starting_game">Starting XPS…</string>
+    <string name="launcher_downloading_update">Downloading update…</string>
+    <string name="launcher_downloading_update_details">(%1$s/%2$s)</string>
+    <string name="launcher_cancelled_manual">Launch paused.</string>
+    <string name="launcher_cancelled_navigated_away">Launch paused.</string>
+    <string name="launcher_cancelled_crash">Launch paused due to a crash.</string>
+    <string name="launcher_cancelled_error">Could not start Geode.</string>
+    <string name="launcher_cancelled_outdated">A XPS update is required.</string>
+    <string name="launcher_cancelled_restart">Restart</string>
+    <string name="launcher_cancelled_resume">Resume</string>
+    <string name="launcher_cancelled_retry">Retry</string>
+    <string name="launcher_cancelled_help_alt">Help</string>
+    <string name="launcher_in_safe_mode">Starting in safe mode…</string>
 
     <!-- Updater strings -->
     <string name="release_fetch_failed">Update failed.\n%1$s</string>
@@ -55,27 +89,31 @@
     <string name="release_fetch_cancelled">Update cancelled.</string>
     <string name="release_fetch_button_retry">Retry</string>
     <string name="release_fetch_button_cancel">Cancel</string>
+    <string name="release_fetch_try_later">Please try again later.</string>
     <string name="release_fetch_manual_check_required">Externally managed library in use, please manually check for updates if you want to overwrite it.</string>
 
     <!-- GeometryDashActivity strings -->
     <string name="load_failed_link_error">Failed to link libraries</string>
     <string name="load_failed_link_error_description">Game libraries could not be found. Try to:</string>
-    <string name="load_failed_abi_error">The architecture of the launcher and Geometry Dash do not match. Try to:</string>
+    <string name="load_failed_abi_error">The architecture of the launcher and XPS do not match. Try to:</string>
     <string name="load_failed_generic_error">Failed to load Geode</string>
     <string name="load_failed_generic_error_description">Uncaught error during game load. Try to:</string>
     <string name="load_failed_crashed">Geode crashed</string>
     <string name="load_failed_crashed_description">A crash was reported during the last session. Try to:</string>
-    <string name="load_failed_recommendation_reinstall">Reinstall Geometry Dash from the Play Store.</string>
+    <string name="load_failed_recommendation_reinstall">Reinstall XPS.</string>
     <string name="load_failed_recommendation_switch_32bit_abi">Install the 32-bit version of the launcher.</string>
     <string name="load_failed_recommendation_switch_64bit_abi">Install the non 32-bit version of the launcher.</string>
-    <string name="load_failed_recommendation_update">Verify that the latest versions of the launcher and Geometry Dash are installed.</string>
+    <string name="load_failed_recommendation_update">Verify that the latest versions of the launcher and XPS are installed.</string>
     <string name="load_failed_recommendation_report">Report this issue to the developers.</string>
     <string name="load_failed_recommendation_safe_mode">Hold the Launch button to launch in safe mode.</string>
+    <string name="load_failed_recommendation_dev_stl">Devs: If this is a locally built Geode version, please use the c++_shared ANDROID_STL!</string>
 
     <string name="message_box_cancel">Cancel</string>
     <string name="message_box_accept">OK</string>
     <string name="message_box_continue">Continue</string>
     <string name="missing_permissions">Missing required permissions for this action!</string>
+    <string name="no_file_selected">File selection cancelled.</string>
+    <string name="file_select_error">Failed to get file.</string>
 
     <!-- SettingsActivity strings -->
     <string name="title_activity_settings">Settings</string>
@@ -85,7 +123,6 @@
     <string name="text_copied">Copied to clipboard.</string>
 
     <string name="preference_category_testing">General</string>
-    <string name="preference_load_testing_name">Load files from /test</string>
     <string name="preference_load_automatically_name">Automatically launch</string>
     <string name="preference_load_automatically_description">Launches the game after a short delay.</string>
     <string name="preferences_copy_external_button">Copy external files directory</string>
@@ -98,20 +135,76 @@
     <string name="preference_theme_light">Light</string>
     <string name="preference_theme_dark">Dark</string>
     <string name="preference_black_background_name">Black background in dark theme</string>
+    <string name="preference_force_hrr">Force maximum refresh rate</string>
+    <string name="preference_enable_redesign">✨ Enable UI refresh</string>
 
-    <string name="preference_display_mode_name">Screen scale</string>
-    <string name="preference_display_mode_select">Select screen scale</string>
-    <string name="preference_display_mode_legacy">Limited (16:9)</string>
+    <string name="preference_display_mode_name">Display mode</string>
+    <string name="preference_display_mode_select">Select display mode</string>
+    <string name="preference_display_mode_legacy">Limited (Custom)</string>
     <string name="preference_display_mode_fullscreen">Edge-to-edge</string>
     <string name="preference_display_mode_default">Default</string>
 
+    <string name="preference_custom_aspect_ratio_name">Aspect ratio</string>
+    <string name="preference_custom_aspect_ratio_description">Limits aspect ratio of the game.</string>
+    <string name="preference_custom_aspect_ratio_select">Select aspect ratio</string>
+    <string name="preference_custom_aspect_ratio_16x9">16:9</string>
+    <string name="preference_custom_aspect_ratio_16x10">16:10</string>
+    <string name="preference_custom_aspect_ratio_4x3">4:3</string>
+    <string name="preference_custom_aspect_ratio_1x1">1:1</string>
+
+    <string name="preference_screen_zoom_name">Screen zoom</string>
+    <string name="preference_screen_zoom_description">Reduces the size of the game window.</string>
+    <string name="preference_screen_zoom_select">Edit screen zoom</string>
+    <string name="preference_screen_zoom_fit_name">Fit to screen</string>
+
+    <string name="preference_limit_framerate_name">Limit max framerate</string>
+    <string name="preference_limit_framerate_description">Limits framerate during rendering.</string>
+    <string name="preference_limit_framerate_select">Edit maximum framerate</string>
+    <string name="preference_limit_framerate_default">Disabled</string>
+    <string name="preference_limit_framerate_label">Framerate</string>
+    <string name="preference_limit_framerate_suffix">FPS</string>
+    <string name="preference_limit_framerate_value">%1$d FPS</string>
+    <string name="preference_limit_framerate_error_max">This device supports at most %1$s FPS.</string>
+    <string name="preference_limit_framerate_error_min">Framerate must be at least %1$s FPS.</string>
+    <string name="preference_limit_framerate_subtract">Decrement</string>
+    <string name="preference_limit_framerate_add">Increment</string>
+    <string name="preference_limit_framerate_reset">Disable</string>
+
     <string name="preference_category_updater">Updates</string>
     <string name="preference_update_automatically_name">Enable automatic updates</string>
     <string name="preference_release_channel_name">Use nightly release channel</string>
 
+    <string name="preference_category_gameplay">Gameplay</string>
+
+    <string name="preference_release_channel_tag_name">Release channel</string>
+    <string name="preference_release_channel_select">Select release channel</string>
+    <string name="preference_release_channel_stable">Stable</string>
+    <string name="preference_release_channel_beta">Pre-release</string>
+    <string name="preference_release_channel_nightly">Nightly</string>
+
+    <string name="preference_category_about">About</string>
+
+    <string name="preference_launcher_version_name">Android Launcher</string>
+    <string name="preference_launcher_version_description">v%1$s</string>
+    <string name="preference_launcher_version">Android Launcher v%1$s</string>
+
+    <string name="preference_loader_version_name">Geode</string>
+    <string name="preference_loader_version_description">%1$s</string>
+    <string name="preference_loader_version">Geode %1$s</string>
+
+    <string name="preference_game_version_name">XPS</string>
+    <string name="preference_game_version_description">%1$s (%2$s)</string>
+    <string name="preference_game_version">XPS %1$s (%2$s)</string>
+    <string name="preference_game_source_google">Google</string>
+    <string name="preference_game_source_amazon">Amazon</string>
+    <string name="preference_game_source_unknown">Unknown</string>
+
+    <string name="preference_architecture_name">Device</string>
+    <string name="preference_architecture_description">%1$s (%2$s)</string>
+    <string name="preference_architecture">%1$s (%2$s)</string>
+
     <string name="preference_check_for_updates_button">Check for updates</string>
     <string name="preference_check_for_updates_description">Current loader version: %1$s</string>
-    <string name="preference_launcher_version">Geode Launcher v%1$s</string>
     <string name="preference_check_for_updates_failed">Update failed. See logs for more details.</string>
     <string name="preference_check_for_updates_none_found">No updates found.</string>
     <string name="preference_check_for_updates_success">Geode has been updated!</string>
@@ -119,12 +212,26 @@
     <string name="preference_check_for_updates_no_internet">No internet found.</string>
     <string name="preference_check_for_updates_already_updating">An update is already in progress!</string>
 
-    <string name="preference_category_developer">Developer</string>
+    <string name="preference_category_developer">Advanced</string>
     <string name="preference_launch_arguments_name">Launch arguments</string>
     <string name="preference_launch_arguments_set_title">Set launch arguments</string>
-    <string name="preference_ignore_load_failure_name">Ignore loader errors</string>
     <string name="preference_text_clear">Clear</string>
 
+    <string name="preference_open_developer_options">Open developer options</string>
+
+    <string name="preference_profiles">Profiles</string>
+    <string name="preference_profiles_create">Create profile</string>
+    <string name="preference_profiles_name">Change profile</string>
+    <string name="preference_profiles_select">Select profile</string>
+    <string name="preference_profiles_create_name">Profile name</string>
+    <string name="preference_profiles_create_action">Create</string>
+    <string name="preference_profiles_select_value">%1$s</string>
+    <string name="preference_profiles_current">Current profile: %1$s</string>
+    <string name="preference_profiles_create_info">This profile will be created at %1$s.</string>
+    <string name="preference_profiles_create_duplicate">A profile with this name already exists.</string>
+    <string name="preference_profiles_delete_alt">Delete</string>
+    <string name="preference_profiles_delete_undo_alt">Undo</string>
+
     <!-- ApplicationLogsActivity strings -->
     <string name="title_activity_application_logs">Application Logs</string>
     <string name="application_logs_no_logs">No logs available.</string>
@@ -139,4 +246,12 @@
     <string name="application_logs_default_filename" translatable="false">launcher_logcat.txt</string>
     <string name="application_logs_crash_only">Show Crash Buffer</string>
     <string name="application_logs_crash_only_enabled_alt">Enabled</string>
+
+    <string name="title_activity_developer_settings">Developer Settings</string>
+    <string name="preference_developer_mode">Enable developer options</string>
+    <string name="preference_developer_mode_about">Developer mode enables some options that may make the game unstable. Please do not modify them unless you know what you\'re doing!\nThese options may change behavior, or be removed entirely in future updates.</string>
+    <string name="preference_developer_update_notice">Enabling developer mode automatically disallows the updater from overwriting custom loader builds.</string>
+
+    <string name="preference_override_exceptions_name">Custom exceptions fix symbols</string>
+    <string name="preference_override_exceptions_description">Uses exception_symbols.txt to patch</string>
 </resources>

app/src/main/res/xml/game_mode_config.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<game-mode-config
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    tools:targetApi="33"
+    android:supportsBatteryGameMode="false"
+    android:supportsPerformanceGameMode="false"
+    android:allowGameFpsOverride="false" />

build.gradle.kts

@@ -1,14 +1,14 @@
 buildscript {
-    val composeBOM by extra("2024.02.00")
-    val composeCompiler by extra("1.5.9")
+    val composeBOM by extra("2025.01.00")
 }
 
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 plugins {
-    id("com.android.application") version "8.2.2" apply false
-    id("com.android.library") version "8.2.2" apply false
-    id("org.jetbrains.kotlin.android") version "1.9.22" apply false
-    id("org.jetbrains.kotlin.plugin.serialization") version "1.9.22" apply false
+    id("com.android.application") version "8.7.3" apply false
+    id("com.android.library") version "8.7.3" apply false
+    id("org.jetbrains.kotlin.android") version "2.1.0" apply false
+    id("org.jetbrains.kotlin.plugin.serialization") version "2.1.0" apply false
+    id("org.jetbrains.kotlin.plugin.compose") version "2.1.0" apply false
 }
 
 tasks.register<Delete>("clean") {

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.12-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

gradlew

@@ -15,6 +15,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+# SPDX-License-Identifier: Apache-2.0
+#
 
 ##############################################################################
 #
@@ -55,7 +57,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
@@ -84,7 +86,8 @@ done
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
 # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
+' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum

gradlew.bat

@@ -13,6 +13,8 @@
 @rem See the License for the specific language governing permissions and
 @rem limitations under the License.
 @rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
 
 @if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
@@ -43,11 +45,11 @@ set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
 if %ERRORLEVEL% equ 0 goto execute
 
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
@@ -57,11 +59,11 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
 if exist "%JAVA_EXE%" goto execute
 
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail