cargo.lock per request #105

Bump glob and semantic-release

.github/workflows/build.yml

@@ -142,3 +142,24 @@ jobs:
           includeUpdaterJson: true
           tauriScript: 'npm run tauri'
           args: ${{ matrix.args }}
+
+  publish-release:
+    name: Publish release
+    needs: [create-release, build-tauri]
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: write
+
+    steps:
+      - name: Publish GitHub release (unset draft)
+        uses: actions/github-script@v6
+        with:
+          script: |
+            const release_id = Number("${{ needs.create-release.outputs.release_id }}");
+
+            await github.rest.repos.updateRelease({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              release_id,
+              draft: false
+            });

.gitignore

@@ -12,9 +12,7 @@ dist
 dist-ssr
 docs
 *.local
-*.lock
 .env
-CHANGELOG.md
 
 # Editor directories and files
 .vscode/*

CHANGELOG.md

@@ -1,3 +1,71 @@
+## [1.5.0] - 28-03-2026
+
+### Added
+- Anonymous reporting system. Vote on whether CreamLinux or SmokeAPI works for a game
+- Opt-in dialog on first launch explaining what is collected and why
+- Rating button on game cards (only visible when opted in and an unlocker is installed)
+- Community vote display in the unlocker selection dialog and before installing SmokeAPI on Proton games
+- Votes track per-unlocker so CreamLinux and SmokeAPI ratings are independent
+- Previously submitted votes are stored locally so already-cast buttons are disabled on re-open
+- Config now automatically migrates missing fields on update without overwriting existing values
+- API source available at https://github.com/Novattz/Lactose/
+
+## [1.4.2] - 13-03-2026
+
+### Added
+- Added a dialog so users can manually add DLC's incase they are missing from the steam api
+
+### Fixed
+- Fixed an issue where if the libsteam_api.so file is nested too deeply in a game causing the app to not find it.
+
+## [1.4.1] - 18-01-2026
+
+### Added
+- Dramatically reduced the time that bitness detection takes to detect game bitness
+
+## [1.4.0] - 17-01-2026
+
+### Added
+- Unlocker selection dialog for native games, allowing users to choose between CreamLinux and SmokeAPI
+- Game bitness detection
+
+### Fixed
+- Cache now validates if expected files are missing.
+
+## [1.3.5] - 09-01-2026
+
+### Changed
+- Redesigned conflict detection dialog to show all conflicts at once
+- Integrated Steam launch option reminder directly into the conflict dialog
+
+### Fixed
+- Improved UX by allowing users to resolve conflicts in any order or defer to later
+
+## [1.3.4] - 03-01-2026
+
+### Added
+- Disclaimer dialog explaining that CreamLinux Installer manages DLC IDs, not actual DLC files
+- User config stored in `~/.config/creamlinux/config.json`
+- **"Don't show again" option**: Users can permanently dismiss the disclaimer via checkbox
+
+## [1.3.3] - 26-12-2025
+
+### Added
+- Platform conflict detection
+- Automatic removal of incompatible unlocker files when switching between Native/Proton
+- Reminder dialog for steam launch options after creamlinux removal
+- Conflict dialog to show which game had the conflict
+
+## [1.3.2] - 23-12-2025
+
+### Added
+- New dropdown component
+- Settings dialog for SmokeAPI configuration
+- Update creamlinux config functionality
+
+### Changed
+- Adjusted styling for CreamLinux settings dialog
+
 ## [1.3.0] - 22-12-2025
 
 ### Added

LICENSE.md

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Tickbase
+Copyright (c) 2026 Tickbase
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,10 +1,10 @@
 # CreamLinux
 
-CreamLinux is a GUI application for Linux that simplifies the management of DLC in Steam games. It provides a user-friendly interface to install and configure CreamAPI (for native Linux games) and SmokeAPI (for Windows games running through Proton).
+CreamLinux is a GUI application for Linux that simplifies the management of DLC IDs in Steam games. It provides a user-friendly interface to install and configure CreamAPI (for native Linux games) and SmokeAPI (for Windows games running through Proton).
 
 ## Watch the demo here:
 
-[![Watch the demo](./src/assets/screenshot.png)](https://www.youtube.com/watch?v=ZunhZnKFLlg)
+[![Watch the demo](./src/assets/screenshot1.png)](https://www.youtube.com/watch?v=neUDotrqnDM)
 
 ## Beta Status
 
@@ -61,7 +61,7 @@ While the core functionality is working, please be aware that this is an early r
 
    ```bash
    git clone https://github.com/Novattz/creamlinux-installer.git
-   cd creamlinux
+   cd creamlinux-installer
    ```
 
 2. Install dependencies:
@@ -124,7 +124,7 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE.md) f
 
 ## Credits
 
-- [Creamlinux](https://github.com/anticitizn/creamlinux) - Native DLC support
+- [Creamlinux](https://github.com/anticitizn/creamlinux) - Native support
 - [SmokeAPI](https://github.com/acidicoala/SmokeAPI) - Proton support
 - [Tauri](https://tauri.app/) - Framework for building the desktop application
 - [React](https://reactjs.org/) - UI library

package.json

@@ -1,7 +1,7 @@
 {
   "name": "creamlinux",
   "private": true,
-  "version": "1.3.0",
+  "version": "1.5.0",
   "type": "module",
   "author": "Tickbase",
   "repository": "https://github.com/Novattz/creamlinux-installer",
@@ -40,14 +40,14 @@
     "eslint": "^9.22.0",
     "eslint-plugin-react-hooks": "^5.2.0",
     "eslint-plugin-react-refresh": "^0.4.19",
-    "glob": "^11.0.2",
+    "glob": "^11.1.0",
     "globals": "^16.0.0",
     "node-fetch": "^3.3.2",
     "sass-embedded": "^1.86.3",
-    "semantic-release": "^24.2.4",
+    "semantic-release": "^25.0.2",
     "typescript": "~5.7.2",
     "typescript-eslint": "^8.26.1",
-    "vite": "^6.3.5",
+    "vite": "^6.4.1",
     "vite-plugin-svgr": "^4.3.0"
   }
 }

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "creamlinux-installer"
-version = "1.3.0"
+version = "1.5.0"
 description = "DLC Manager for Steam games on Linux"
 authors = ["tickbase"]
 license = "MIT"
@@ -32,6 +32,8 @@ tauri-plugin-fs = "2.0.0-rc"
 num_cpus = "1.16.0"
 tauri-plugin-process = "2"
 async-trait = "0.1.89"
+sha2 = "0.10.9"
+rand = "0.9.2"
 
 [features]
 custom-protocol = ["tauri/custom-protocol"]

src-tauri/src/cache/mod.rs

@@ -2,9 +2,10 @@ mod storage;
 mod version;
 
 pub use storage::{
-    get_creamlinux_version_dir, get_smokeapi_version_dir, is_cache_initialized,
-    list_creamlinux_files, list_smokeapi_dlls, read_versions, update_creamlinux_version,
-    update_smokeapi_version,
+    get_creamlinux_version_dir, get_smokeapi_version_dir,
+    list_creamlinux_files, list_smokeapi_files, read_versions, 
+    update_creamlinux_version, update_smokeapi_version, validate_smokeapi_cache,
+    validate_creamlinux_cache, get_cache_dir,
 };
 
 pub use version::{
@@ -22,39 +23,87 @@ use std::collections::HashMap;
 pub async fn initialize_cache() -> Result<(), String> {
     info!("Initializing cache...");
 
-    // Check if cache is already initialized
-    if is_cache_initialized()? {
-        info!("Cache already initialized");
-        return Ok(());
+    let versions = read_versions()?;
+    let mut needs_smokeapi = false;
+    let mut needs_creamlinux = false;
+
+    // Check if SmokeAPI is properly cached
+    if versions.smokeapi.latest.is_empty() {
+        info!("No SmokeAPI version in manifest");
+        needs_smokeapi = true
+    } else {
+        // Validate that all files exist
+        match validate_smokeapi_cache(&versions.smokeapi.latest) {
+            Ok(true) => {
+                info!("SmokeAPI cache validated successfully");
+            }
+            Ok(false) => {
+                info!("SmokeAPI cache incomplete, re-downloading");
+                needs_smokeapi = true;
+            }
+            Err(e) => {
+                warn!("Failed to validate SmokeAPI cache: {}, re-downloading", e);
+                needs_smokeapi = true;
+            }
+        }
     }
 
-    info!("Cache not initialized, downloading unlockers...");
+    // Check if CreamLinux is properly cached
+    if versions.creamlinux.latest.is_empty() {
+        info!("No CreamLinux version in manifest");
+        needs_creamlinux = true;
+    } else {
+        match validate_creamlinux_cache(&versions.creamlinux.latest) {
+            Ok(true) => {
+                info!("CreamLinux cache validated successfully");
+            }
+            Ok(false) => {
+                info!("CreamLinux cache incomplete, re-downloading");
+                needs_creamlinux = true;
+            }
+            Err(e) => {
+                warn!("Failed to validate CreamLinux cache: {}, re-downloading", e);
+                needs_creamlinux = true;
+            }
+        }
+    }
 
     // Download SmokeAPI
-    match SmokeAPI::download_to_cache().await {
-        Ok(version) => {
-            info!("Downloaded SmokeAPI version: {}", version);
-            update_smokeapi_version(&version)?;
-        }
-        Err(e) => {
-            error!("Failed to download SmokeAPI: {}", e);
-            return Err(format!("Failed to download SmokeAPI: {}", e));
+    if needs_smokeapi {
+        info!("Downloading SmokeAPI...");
+        match SmokeAPI::download_to_cache().await {
+            Ok(version) => {
+                info!("Downloaded SmokeAPI version: {}", version);
+                update_smokeapi_version(&version)?;
+            }
+            Err(e) => {
+                error!("Failed to download SmokeAPI: {}", e);
+                return Err(format!("Failed to download SmokeAPI: {}", e));
+            }
         }
     }
 
     // Download CreamLinux
-    match CreamLinux::download_to_cache().await {
-        Ok(version) => {
-            info!("Downloaded CreamLinux version: {}", version);
-            update_creamlinux_version(&version)?;
-        }
-        Err(e) => {
-            error!("Failed to download CreamLinux: {}", e);
-            return Err(format!("Failed to download CreamLinux: {}", e));
+    if needs_creamlinux {
+        info!("Downloading CreamLinux...");
+        match CreamLinux::download_to_cache().await {
+            Ok(version) => {
+                info!("Downloaded CreamLinux version: {}", version);
+                update_creamlinux_version(&version)?;
+            }
+            Err(e) => {
+                error!("Failed to download CreamLinux: {}", e);
+                return Err(format!("Failed to download CreamLinux: {}", e));
+            }
         }
     }
 
-    info!("Cache initialization complete");
+    if !needs_smokeapi && !needs_creamlinux {
+        info!("Cache already initialized and validated");
+    } else {
+        info!("Cache initialization complete");
+    }
+
     Ok(())
 }
 

src-tauri/src/cache/storage.rs

@@ -204,12 +204,6 @@ pub fn update_creamlinux_version(new_version: &str) -> Result<(), String> {
     Ok(())
 }
 
-// Check if the cache is initialized (has both unlockers cached)
-pub fn is_cache_initialized() -> Result<bool, String> {
-    let versions = read_versions()?;
-    Ok(!versions.smokeapi.latest.is_empty() && !versions.creamlinux.latest.is_empty())
-}
-
 // Get the SmokeAPI DLL path for the latest cached version
 #[allow(dead_code)]
 pub fn get_smokeapi_dll_path() -> Result<PathBuf, String> {
@@ -233,8 +227,8 @@ pub fn get_creamlinux_files_dir() -> Result<PathBuf, String> {
     get_creamlinux_version_dir(&versions.creamlinux.latest)
 }
 
-// List all SmokeAPI DLL files in the cached version directory
-pub fn list_smokeapi_dlls() -> Result<Vec<PathBuf>, String> {
+/// List all SmokeAPI files in the cached version directory
+pub fn list_smokeapi_files() -> Result<Vec<PathBuf>, String> {
     let versions = read_versions()?;
     if versions.smokeapi.latest.is_empty() {
         return Ok(Vec::new());
@@ -249,17 +243,20 @@ pub fn list_smokeapi_dlls() -> Result<Vec<PathBuf>, String> {
     let entries = fs::read_dir(&version_dir)
         .map_err(|e| format!("Failed to read SmokeAPI directory: {}", e))?;
 
-    let mut dlls = Vec::new();
+    let mut files = Vec::new();
     for entry in entries {
         if let Ok(entry) = entry {
             let path = entry.path();
-            if path.extension().and_then(|s| s.to_str()) == Some("dll") {
-                dlls.push(path);
+            // Get both .dll and .so files
+            if let Some(ext) = path.extension().and_then(|s| s.to_str()) {
+                if ext == "dll" || ext == "so" {
+                    files.push(path);
+                }
             }
         }
     }
 
-    Ok(dlls)
+    Ok(files)
 }
 
 // List all CreamLinux files in the cached version directory
@@ -289,4 +286,70 @@ pub fn list_creamlinux_files() -> Result<Vec<PathBuf>, String> {
     }
 
     Ok(files)
+}
+
+/// Validate that all required files exist for SmokeAPI
+pub fn validate_smokeapi_cache(version: &str) -> Result<bool, String> {
+    let version_dir = get_smokeapi_version_dir(version)?;
+
+    if !version_dir.exists() {
+        return Ok(false);
+    }
+
+    // Required files for SmokeAPI
+    let required_files = vec![
+        "smoke_api32.dll",
+        "smoke_api64.dll",
+        "libsmoke_api32.so",
+        "libsmoke_api64.so",
+    ];
+
+    let mut missing_files = Vec::new();
+
+    for file in &required_files {
+        let file_path = version_dir.join(file);
+        if !file_path.exists() {
+            missing_files.push(file.to_string());
+        }
+    }
+
+    if !missing_files.is_empty() {
+        info!("Missing required files in cache: {:?}", missing_files);
+        return Ok(false);
+    }
+
+    Ok(true)
+}
+
+/// Validate that all required files exist for CreamLinux
+pub fn validate_creamlinux_cache(version: &str) -> Result<bool, String> {
+    let version_dir = get_creamlinux_version_dir(version)?;
+
+    if !version_dir.exists() {
+        return Ok(false);
+    }
+
+    // Required files for CreamLinux
+    let required_files = vec![
+        "cream.sh",
+        "cream_api.ini",
+        "lib32Creamlinux.so",
+        "lib64Creamlinux.so",
+    ];
+
+    let mut missing_files = Vec::new();
+
+    for file in &required_files {
+        let file_path = version_dir.join(file);
+        if !file_path.exists() {
+            missing_files.push(file.to_string());
+        }
+    }
+
+    if !missing_files.is_empty() {
+        info!("Missing required files in cache: {:?}", missing_files);
+        return Ok(false);
+    }
+
+    Ok(true)
 }

src-tauri/src/config.rs

@@ -0,0 +1,162 @@
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::path::PathBuf;
+use log::info;
+
+// User configuration structure
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Config {
+    // Whether to show the disclaimer on startup
+    pub show_disclaimer: bool,
+    // Reporting / compatibility voting
+    pub reporting_opted_in: bool,
+    pub reporting_has_seen_prompt: bool,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            show_disclaimer: true,
+            reporting_opted_in: false,
+            reporting_has_seen_prompt: false,
+        }
+    }
+}
+
+// Get the config directory path (~/.config/creamlinux)
+fn get_config_dir() -> Result<PathBuf, String> {
+    let home = std::env::var("HOME")
+        .map_err(|_| "Failed to get HOME directory".to_string())?;
+    
+    let config_dir = PathBuf::from(home).join(".config").join("creamlinux");
+    Ok(config_dir)
+}
+
+// Get the config file path
+fn get_config_path() -> Result<PathBuf, String> {
+    let config_dir = get_config_dir()?;
+    Ok(config_dir.join("config.json"))
+}
+
+// Ensure the config directory exists
+fn ensure_config_dir() -> Result<(), String> {
+    let config_dir = get_config_dir()?;
+    
+    if !config_dir.exists() {
+        fs::create_dir_all(&config_dir)
+            .map_err(|e| format!("Failed to create config directory: {}", e))?;
+        info!("Created config directory at {:?}", config_dir);
+    }
+    
+    Ok(())
+}
+
+// Load configuration from disk
+pub fn load_config() -> Result<Config, String> {
+    ensure_config_dir()?;
+    
+    let config_path = get_config_path()?;
+    
+    // If config file doesn't exist, create default config
+    if !config_path.exists() {
+        let default_config = Config::default();
+        save_config(&default_config)?;
+        info!("Created default config file at {:?}", config_path);
+        return Ok(default_config);
+    }
+    
+    // Read and parse config file
+    let config_str = fs::read_to_string(&config_path)
+        .map_err(|e| format!("Failed to read config file: {}", e))?;
+
+    let mut on_disk: serde_json::Value = serde_json::from_str(&config_str)
+        .map_err(|e| format!("Failed to parse config file: {}", e))?;
+
+    // Serialize the defaults into a Value so we can iterate their keys
+    let defaults = serde_json::to_value(Config::default())
+        .map_err(|e| format!("Failed to serialize default config: {}", e))?;
+
+    // For every key that exists in the current Config but is absent from the
+    // on-disk JSON, inject the default value. Keys that are already present
+    // are left completely untouched.
+    let mut migrated = false;
+    if let Some(default_obj) = defaults.as_object() {
+        let missing: Vec<(String, serde_json::Value)> = default_obj
+            .iter()
+            .filter(|(key, _)| {
+                on_disk
+                    .as_object()
+                    .map_or(false, |d| !d.contains_key(*key))
+            })
+            .map(|(key, val)| (key.clone(), val.clone()))
+            .collect();
+ 
+        if let Some(disk_obj) = on_disk.as_object_mut() {
+            for (key, value) in missing {
+                info!("Config migration: adding missing field '{}' with default value", key);
+                disk_obj.insert(key, value);
+                migrated = true;
+            }
+        }
+    }
+
+    // Deserialize the (possiblyh augmented) value into Config
+    let config: Config = serde_json::from_value(on_disk)
+        .map_err(|e| format!("Failed to deserialize config: {}", e))?;
+
+    // Persist the migrated file so the next launch doesn't need to do this again
+    if migrated {
+        save_config(&config)?;
+        info!("Config migrated - new fields written to disk");
+    } else {
+        info!("Loaded config from {:?}", config_path);
+    }
+    
+    Ok(config)
+}
+
+// Save configuration to disk
+pub fn save_config(config: &Config) -> Result<(), String> {
+    ensure_config_dir()?;
+    
+    let config_path = get_config_path()?;
+    
+    let config_str = serde_json::to_string_pretty(config)
+        .map_err(|e| format!("Failed to serialize config: {}", e))?;
+    
+    fs::write(&config_path, config_str)
+        .map_err(|e| format!("Failed to write config file: {}", e))?;
+    
+    info!("Saved config to {:?}", config_path);
+    Ok(())
+}
+
+// Update a specific config value
+pub fn update_config<F>(updater: F) -> Result<Config, String>
+where
+    F: FnOnce(&mut Config),
+{
+    let mut config = load_config()?;
+    updater(&mut config);
+    save_config(&config)?;
+    Ok(config)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_default_config() {
+        let config = Config::default();
+        assert!(config.show_disclaimer);
+    }
+
+    #[test]
+    fn test_config_serialization() {
+        let config = Config::default();
+        let json = serde_json::to_string(&config).unwrap();
+        let parsed: Config = serde_json::from_str(&json).unwrap();
+        assert_eq!(config.show_disclaimer, parsed.show_disclaimer);
+    }
+}

src-tauri/src/installer/mod.rs

@@ -241,8 +241,26 @@ async fn uninstall_creamlinux(game: Game, app_handle: AppHandle) -> Result<(), S
     Ok(())
 }
 
-// Install SmokeAPI to a game
 async fn install_smokeapi(game: Game, app_handle: AppHandle) -> Result<(), String> {
+    // Check if native or proton and route accordingly
+    if game.native {
+        install_smokeapi_native(game, app_handle).await
+    } else {
+        install_smokeapi_proton(game, app_handle).await
+    }
+}
+
+async fn uninstall_smokeapi(game: Game, app_handle: AppHandle) -> Result<(), String> {
+    // Check if native or proton and route accordingly
+    if game.native {
+        uninstall_smokeapi_native(game, app_handle).await
+    } else {
+        uninstall_smokeapi_proton(game, app_handle).await
+    }
+}
+
+// Install SmokeAPI to a proton game
+async fn install_smokeapi_proton(game: Game, app_handle: AppHandle) -> Result<(), String> {
     if game.native {
         return Err("SmokeAPI can only be installed on Proton/Windows games".to_string());
     }
@@ -286,8 +304,8 @@ async fn install_smokeapi(game: Game, app_handle: AppHandle) -> Result<(), Strin
     Ok(())
 }
 
-// Uninstall SmokeAPI from a game
-async fn uninstall_smokeapi(game: Game, app_handle: AppHandle) -> Result<(), String> {
+// Uninstall SmokeAPI from a proton game
+async fn uninstall_smokeapi_proton(game: Game, app_handle: AppHandle) -> Result<(), String> {
     if game.native {
         return Err("SmokeAPI can only be uninstalled from Proton/Windows games".to_string());
     }
@@ -329,6 +347,99 @@ async fn uninstall_smokeapi(game: Game, app_handle: AppHandle) -> Result<(), Str
     Ok(())
 }
 
+// Install SmokeAPI to a native Linux game
+async fn install_smokeapi_native(
+    game: Game,
+    app_handle: AppHandle,
+) -> Result<(), String> {
+
+    info!("Installing SmokeAPI (native) for game: {}", game.title);
+    let game_title = game.title.clone();
+
+    emit_progress(
+        &app_handle,
+        &format!("Installing SmokeAPI for {}", game_title),
+        "Detecting game architecture...",
+        20.0,
+        false,
+        false,
+        None,
+    );
+
+    emit_progress(
+        &app_handle,
+        &format!("Installing SmokeAPI for {}", game_title),
+        "Installing from cache...",
+        50.0,
+        false,
+        false,
+        None,
+    );
+
+    // Install SmokeAPI for native Linux (empty string for api_files_str)
+    SmokeAPI::install_to_game(&game.path, "")
+        .await
+        .map_err(|e| format!("Failed to install SmokeAPI: {}", e))?;
+
+    // Update version manifest
+    let cached_versions = crate::cache::read_versions()?;
+    update_game_smokeapi_version(&game.path, cached_versions.smokeapi.latest)?;
+
+    emit_progress(
+        &app_handle,
+        &format!("Installation Completed: {}", game_title),
+        "SmokeAPI has been installed successfully!",
+        100.0,
+        true,
+        false,
+        None,
+    );
+
+    info!("SmokeAPI (native) installation completed for: {}", game_title);
+    Ok(())
+}
+
+// Uninstall SmokeAPI from a native Linux game
+async fn uninstall_smokeapi_native(game: Game, app_handle: AppHandle) -> Result<(), String> {
+    if !game.native {
+        return Err("This function is only for native Linux games".to_string());
+    }
+
+    let game_title = game.title.clone();
+    info!("Uninstalling SmokeAPI (native) from game: {}", game_title);
+
+    emit_progress(
+        &app_handle,
+        &format!("Uninstalling SmokeAPI from {}", game_title),
+        "Removing SmokeAPI files...",
+        50.0,
+        false,
+        false,
+        None,
+    );
+
+    // Uninstall SmokeAPI (empty string for api_files_str)
+    SmokeAPI::uninstall_from_game(&game.path, "")
+        .await
+        .map_err(|e| format!("Failed to uninstall SmokeAPI: {}", e))?;
+
+    // Remove version from manifest
+    remove_smokeapi_version(&game.path)?;
+
+    emit_progress(
+        &app_handle,
+        &format!("Uninstallation Completed: {}", game_title),
+        "SmokeAPI has been removed successfully!",
+        100.0,
+        true,
+        false,
+        None,
+    );
+
+    info!("SmokeAPI (native) uninstallation completed for: {}", game_title);
+    Ok(())
+}
+
 // Fetch DLC details from Steam API (simple version without progress)
 pub async fn fetch_dlc_details(app_id: &str) -> Result<Vec<DlcInfo>, String> {
     let client = reqwest::Client::new();

src-tauri/src/main.rs

@@ -4,11 +4,17 @@
 )]
 
 mod cache;
+mod reporting;
+mod utils;
 mod dlc_manager;
 mod installer;
 mod searcher;
 mod unlockers;
+mod smokeapi_config;
+mod config;
 
+use crate::config::Config;
+use crate::unlockers::{CreamLinux, SmokeAPI, Unlocker};
 use dlc_manager::DlcInfoWithState;
 use installer::{Game, InstallerAction, InstallerType};
 use log::{debug, error, info, warn};
@@ -44,6 +50,19 @@ pub struct AppState {
     fetch_cancellation: Arc<AtomicBool>,
 }
 
+// Load the current configuration
+#[tauri::command]
+fn load_config() -> Result<Config, String> {
+    config::load_config()
+}
+
+// Update configuration
+#[tauri::command]
+fn update_config(config_data: Config) -> Result<Config, String> {
+    config::save_config(&config_data)?;
+    Ok(config_data)
+}
+
 #[tauri::command]
 fn get_all_dlcs_command(game_path: String) -> Result<Vec<DlcInfoWithState>, String> {
     info!("Getting all DLCs (enabled and disabled) for: {}", game_path);
@@ -434,6 +453,242 @@ async fn install_cream_with_dlcs_command(
     }
 }
 
+#[tauri::command]
+fn read_smokeapi_config(game_path: String) -> Result<Option<smokeapi_config::SmokeAPIConfig>, String> {
+    info!("Reading SmokeAPI config for: {}", game_path);
+    smokeapi_config::read_config(&game_path)
+}
+
+#[tauri::command]
+fn write_smokeapi_config(
+    game_path: String,
+    config: smokeapi_config::SmokeAPIConfig,
+) -> Result<(), String> {
+    info!("Writing SmokeAPI config for: {}", game_path);
+    smokeapi_config::write_config(&game_path, &config)
+}
+
+#[tauri::command]
+fn delete_smokeapi_config(game_path: String) -> Result<(), String> {
+    info!("Deleting SmokeAPI config for: {}", game_path);
+    smokeapi_config::delete_config(&game_path)
+}
+
+#[tauri::command]
+async fn resolve_platform_conflict(
+    game_id: String,
+    conflict_type: String, // "cream-to-proton" or "smoke-to-native"
+    state: State<'_, AppState>,
+    app_handle: tauri::AppHandle,
+) -> Result<Game, String> {
+    info!(
+        "Resolving platform conflict for game {}: {}",
+        game_id, conflict_type
+    );
+
+    let game = {
+        let games = state.games.lock();
+        games
+            .get(&game_id)
+            .cloned()
+            .ok_or_else(|| format!("Game with ID {} not found", game_id))?
+    };
+
+    let game_title = game.title.clone();
+
+    // Emit progress
+    installer::emit_progress(
+        &app_handle,
+        &format!("Resolving Conflict: {}", game_title),
+        "Removing conflicting files...",
+        50.0,
+        false,
+        false,
+        None,
+    );
+
+    // Perform the appropriate removal based on conflict type
+    match conflict_type.as_str() {
+        "cream-to-proton" => {
+            // Remove CreamLinux files (bypassing native check)
+            info!("Removing CreamLinux files from Proton game: {}", game_title);
+            
+            CreamLinux::uninstall_from_game(&game.path, &game.id)
+                .await
+                .map_err(|e| format!("Failed to remove CreamLinux files: {}", e))?;
+
+            // Remove version from manifest
+            crate::cache::remove_creamlinux_version(&game.path)?;
+        }
+        "smoke-to-native" => {
+            // Remove SmokeAPI files (bypassing proton check)
+            info!("Removing SmokeAPI files from native game: {}", game_title);
+            
+            // For native games, we need to manually remove backup files since
+            // the main DLL might already be gone
+            // Look for and remove *_o.dll backup files
+            use walkdir::WalkDir;
+            let mut removed_files = false;
+            
+            for entry in WalkDir::new(&game.path)
+                .max_depth(5)
+                .into_iter()
+                .filter_map(Result::ok)
+            {
+                let path = entry.path();
+                if !path.is_file() {
+                    continue;
+                }
+                
+                let filename = path.file_name().unwrap_or_default().to_string_lossy();
+                
+                // Remove steam_api*_o.dll backup files
+                if filename.starts_with("steam_api") && filename.ends_with("_o.dll") {
+                    match std::fs::remove_file(path) {
+                        Ok(_) => {
+                            info!("Removed SmokeAPI backup file: {}", path.display());
+                            removed_files = true;
+                        }
+                        Err(e) => {
+                            warn!("Failed to remove backup file {}: {}", path.display(), e);
+                        }
+                    }
+                }
+            }
+            
+            // Also try the normal uninstall if api_files are present
+            if !game.api_files.is_empty() {
+                let api_files_str = game.api_files.join(",");
+                if let Err(e) = SmokeAPI::uninstall_from_game(&game.path, &api_files_str).await {
+                    // Don't fail if this errors - we might have already cleaned up manually above
+                    warn!("SmokeAPI uninstall warning: {}", e);
+                }
+            }
+            
+            if !removed_files {
+                warn!("No SmokeAPI files found to remove for: {}", game_title);
+            }
+
+            // Remove version from manifest
+            crate::cache::remove_smokeapi_version(&game.path)?;
+        }
+        _ => return Err(format!("Invalid conflict type: {}", conflict_type)),
+    }
+
+    installer::emit_progress(
+        &app_handle,
+        &format!("Conflict Resolved: {}", game_title),
+        "Conflicting files have been removed successfully!",
+        100.0,
+        true,
+        false,
+        None,
+    );
+
+    // Update game state
+    let updated_game = {
+        let mut games_map = state.games.lock();
+        let game = games_map
+            .get_mut(&game_id)
+            .ok_or_else(|| format!("Game with ID {} not found after conflict resolution", game_id))?;
+
+        match conflict_type.as_str() {
+            "cream-to-proton" => {
+                game.cream_installed = false;
+            }
+            "smoke-to-native" => {
+                game.smoke_installed = false;
+            }
+            _ => {}
+        }
+
+        game.installing = false;
+        game.clone()
+    };
+
+    if let Err(e) = app_handle.emit("game-updated", &updated_game) {
+        warn!("Failed to emit game-updated event: {}", e);
+    }
+
+    info!("Platform conflict resolved successfully for: {}", game_title);
+    Ok(updated_game)
+}
+
+#[tauri::command]
+fn set_reporting_opt_in(opted_in: bool) -> Result<(), String> {
+    config::update_config(|cfg| {
+        cfg.reporting_opted_in = opted_in;
+        cfg.reporting_has_seen_prompt = true;
+    })?;
+ 
+    if opted_in {
+        // Ensure a salt exists so future hashes work immediately
+        reporting::delete_salt().ok(); // clear any stale one first
+        // re-create via generate_user_hash is fine; salt is lazy-created there
+    } else {
+        reporting::delete_salt()?;
+    }
+ 
+    info!("Reporting opt-in set to: {}", opted_in);
+    Ok(())
+}
+ 
+#[tauri::command]
+async fn submit_report(
+    game_id: String,
+    unlocker: String,
+    worked: bool,
+    steam_path: String,
+) -> Result<(), String> {
+    let user_hash = reporting::generate_user_hash(&steam_path)?;
+ 
+    reporting::post_report(reporting::ReportPayload {
+        user_hash,
+        game_id: game_id.clone(),
+        unlocker: unlocker.clone(),
+        worked,
+    })
+    .await?;
+
+    // Always save locally so the UI can reflect the vote immediately,
+    // regardless of opt-in status (the local file is only used client-side).
+    reporting::save_local_report(reporting::LocalReport {
+        game_id,
+        unlocker,
+        worked,
+    })?;
+
+    Ok(())
+}
+
+#[tauri::command]
+fn get_local_reports() -> Vec<reporting::LocalReport> {
+    reporting::load_local_reports()
+}
+
+#[tauri::command]
+async fn get_game_votes(game_id: String) -> Result<Vec<reporting::VoteResult>, String> {
+    let url = format!("https://api.shibe.fun/v1/votes/{}", game_id);
+
+    let client = reqwest::Client::new();
+    let response = client
+        .get(&url)
+        .timeout(std::time::Duration::from_secs(5))
+        .send()
+        .await
+        .map_err(|e| format!("Failed to fetch votes: {}", e))?;
+
+    if !response.status().is_success() {
+        // Non-critical - return empty rather than surfacing an error to the UI
+        return Ok(Vec::new());
+    }
+
+    response
+        .json::<Vec<reporting::VoteResult>>()
+        .await
+        .map_err(|e| format!("Failed to parse votes: {}", e))
+}
+
 fn setup_logging() -> Result<(), Box<dyn std::error::Error>> {
     use log::LevelFilter;
     use log4rs::append::file::FileAppender;
@@ -491,6 +746,16 @@ fn main() {
             get_all_dlcs_command,
             clear_caches,
             abort_dlc_fetch,
+            read_smokeapi_config,
+            write_smokeapi_config,
+            delete_smokeapi_config,
+            resolve_platform_conflict,
+            load_config,
+            update_config,
+            set_reporting_opt_in,
+            submit_report,
+            get_local_reports,
+            get_game_votes,
         ])
         .setup(|app| {
             info!("Tauri application setup");

src-tauri/src/reporting.rs

@@ -0,0 +1,177 @@
+use crate::cache::get_cache_dir;
+use crate::config;
+use log::{info, warn};
+use rand::distr::Alphanumeric;
+use rand::Rng;
+use reqwest::Client;
+use serde::{Serialize, Deserialize};
+use sha2::{Digest, Sha256};
+use std::fs;
+use std::time::Duration;
+
+const API_BASE: &str = "https://api.shibe.fun/v1";
+const SALT_LENGTH: usize = 32;
+ 
+// Report payload
+ 
+#[derive(Serialize, Debug)]
+pub struct ReportPayload {
+    pub user_hash: String,
+    pub game_id: String,
+    /// "creamlinux" | "smokeapi"
+    pub unlocker: String,
+    /// true = worked, false = didn't work
+    pub worked: bool,
+}
+
+/// Mirrors the JSON returned by GET /v1/votes/:game_id
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct VoteResult {
+    pub unlocker: String,
+    pub success: u32,
+    pub fail: u32,
+}
+
+// Local report record
+
+/// One entry in the local reports.json cache.
+/// Tracks what the user has already voted so we can disable buttons in the UI.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct LocalReport {
+    pub game_id: String,
+    pub unlocker: String,   // "creamlinux" | "smokeapi"
+    pub worked: bool,
+}
+
+// reports.json helpers
+
+fn reports_cache_path() -> Result<std::path::PathBuf, String> {
+    Ok(get_cache_dir()?.join("reports.json"))
+}
+
+/// Load all locally recorded votes.
+pub fn load_local_reports() -> Vec<LocalReport> {
+    match reports_cache_path() {
+        Ok(path) if path.exists() => {
+            fs::read_to_string(&path)
+                .ok()
+                .and_then(|s| serde_json::from_str(&s).ok())
+                .unwrap_or_default()
+        }
+        _ => Vec::new(),
+    }
+}
+
+/// Save a new vote to reports.json (or overwrite an existing one for the same
+/// game_id + unlocker combo).
+pub fn save_local_report(report: LocalReport) -> Result<(), String> {
+    let path = reports_cache_path()?;
+    let mut reports = load_local_reports();
+
+    // Upsert: replace existing entry for the same game + unlocker, otherwise push
+    let pos = reports
+        .iter()
+        .position(|r| r.game_id == report.game_id && r.unlocker == report.unlocker);
+
+    match pos {
+        Some(i) => reports[i] = report,
+        None => reports.push(report),
+    }
+
+    let json = serde_json::to_string_pretty(&reports)
+        .map_err(|e| format!("Failed to serialize reports cache: {}", e))?;
+    fs::write(&path, json)
+        .map_err(|e| format!("Failed to write reports cache: {}", e))?;
+
+    Ok(())
+}
+
+// Salt management
+ 
+fn get_or_create_salt() -> Result<String, String> {
+    let salt_path = get_cache_dir()?.join("salt");
+ 
+    if salt_path.exists() {
+        let salt = fs::read_to_string(&salt_path)
+            .map_err(|e| format!("Failed to read salt file: {}", e))?;
+        let salt = salt.trim().to_string();
+ 
+        if salt.len() == SALT_LENGTH {
+            return Ok(salt);
+        }
+ 
+        warn!("Salt file has invalid data, regenerating...");
+    }
+ 
+    let salt: String = rand::rng()
+        .sample_iter(&Alphanumeric)
+        .take(SALT_LENGTH)
+        .map(char::from)
+        .collect();
+ 
+    fs::write(&salt_path, &salt)
+        .map_err(|e| format!("Failed to write salt file: {}", e))?;
+ 
+    info!("Generated new reporting salt");
+    Ok(salt)
+}
+ 
+pub fn delete_salt() -> Result<(), String> {
+    let salt_path = get_cache_dir()?.join("salt");
+ 
+    if salt_path.exists() {
+        fs::remove_file(&salt_path)
+            .map_err(|e| format!("Failed to delete salt: {}", e))?;
+        info!("Deleted reporting salt (user opted out)");
+    }
+    Ok(())
+}
+ 
+// Hash generation
+ 
+pub fn generate_user_hash(steam_path: &str) -> Result<String, String> {
+    let machine_id = fs::read_to_string("/etc/machine-id")
+        .map_err(|e| format!("Failed to read machine-id: {}", e))?;
+    let machine_id = machine_id.trim();
+ 
+    let salt = get_or_create_salt()?;
+    let combined = format!("{}{}{}", machine_id, steam_path, salt);
+ 
+    let mut hasher = Sha256::new();
+    hasher.update(combined.as_bytes());
+    Ok(format!("{:x}", hasher.finalize()))
+}
+ 
+// HTTP
+ 
+pub async fn post_report(payload: ReportPayload) -> Result<(), String> {
+    let cfg = config::load_config()?;
+ 
+    if !cfg.reporting_opted_in {
+        info!("Reporting disabled - skipping report for game {}", payload.game_id);
+        return Ok(());
+    }
+ 
+    let client = Client::new();
+    let url = format!("{}/report", API_BASE);
+ 
+    info!(
+        "Submitting report: game={}, unlocker={}, worked={}",
+        payload.game_id, payload.unlocker, payload.worked
+    );
+ 
+    let response = client
+        .post(&url)
+        .json(&payload)
+        .timeout(Duration::from_secs(10))
+        .send()
+        .await
+        .map_err(|e| format!("Failed to send report: {}", e))?;
+ 
+    if response.status().is_success() {
+        info!("Report submitted successfully");
+        Ok(())
+    } else {
+        Err(format!("Report submission failed: HTTP {}", response.status()))
+    }
+}

src-tauri/src/searcher.rs

@@ -256,22 +256,62 @@ fn check_creamlinux_installed(game_path: &Path) -> bool {
 
 // Check if a game has SmokeAPI installed
 fn check_smokeapi_installed(game_path: &Path, api_files: &[String]) -> bool {
-    if api_files.is_empty() {
-        return false;
+    // For Proton games: check for backup DLL files
+    if !api_files.is_empty() {
+        for api_file in api_files {
+            let api_path = game_path.join(api_file);
+            let api_dir = api_path.parent().unwrap_or(game_path);
+            let api_filename = api_path.file_name().unwrap_or_default();
+
+            // Check for backup file (original file renamed with _o.dll suffix)
+            let backup_name = api_filename.to_string_lossy().replace(".dll", "_o.dll");
+            let backup_path = api_dir.join(backup_name);
+
+            if backup_path.exists() {
+                debug!("SmokeAPI backup file found: {}", backup_path.display());
+                return true;
+            }
+        }
     }
 
-    // SmokeAPI creates backups with _o.dll suffix
-    for api_file in api_files {
-        let api_path = game_path.join(api_file);
-        let api_dir = api_path.parent().unwrap_or(game_path);
-        let api_filename = api_path.file_name().unwrap_or_default();
+    // For Native games: check for lib_steam_api_o.so backup
+    for entry in WalkDir::new(game_path)
+        .max_depth(3)
+        .into_iter()
+        .filter_map(Result::ok)
+    {
+        let path = entry.path();
+        if !path.is_file() {
+            continue;
+        }
 
-        // Check for backup file (original file renamed with _o.dll suffix)
-        let backup_name = api_filename.to_string_lossy().replace(".dll", "_o.dll");
-        let backup_path = api_dir.join(backup_name);
+        let filename = path.file_name().unwrap_or_default().to_string_lossy();
 
-        if backup_path.exists() {
-            debug!("SmokeAPI backup file found: {}", backup_path.display());
+        // Check for native SmokeAPI backup
+        if filename == "libsteam_api_o.so" {
+            debug!("Found native SmokeAPI backup: {}", path.display());
+            return true;
+        }
+    }
+    
+    // Also scan for orphaned backup files (in case the main DLL was removed)
+    // This handles the Proton->Native switch case where steam_api*.dll is gone
+    // but steam_api*_o.dll backup remains
+    for entry in WalkDir::new(game_path)
+        .max_depth(5)
+        .into_iter()
+        .filter_map(Result::ok)
+    {
+        let path = entry.path();
+        if !path.is_file() {
+            continue;
+        }
+        
+        let filename = path.file_name().unwrap_or_default().to_string_lossy();
+        
+        // Look for steam_api*_o.dll backup files (SmokeAPI pattern)
+        if filename.starts_with("steam_api") && filename.ends_with("_o.dll") {
+            debug!("Found orphaned SmokeAPI backup file: {}", path.display());
             return true;
         }
     }
@@ -631,12 +671,10 @@ pub async fn find_installed_games(steamapps_paths: &[PathBuf]) -> Vec<GameInfo>
                 // Check for CreamLinux installation
                 let cream_installed = check_creamlinux_installed(&game_path);
 
-                // Check for SmokeAPI installation (only for non-native games with Steam API DLLs)
-                let smoke_installed = if !is_native && !api_files.is_empty() {
-                    check_smokeapi_installed(&game_path, &api_files)
-                } else {
-                    false
-                };
+                // Check for SmokeAPI installation
+                // For Proton games: check if api_files exist
+                // For Native games: ALSO check for orphaned backup files (proton->native switch)
+                let smoke_installed = check_smokeapi_installed(&game_path, &api_files);
 
                 // Create the game info
                 let game_info = GameInfo {

src-tauri/src/smokeapi_config.rs

@@ -0,0 +1,128 @@
+use log::{info, warn};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::fs;
+use std::path::Path;
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct SmokeAPIConfig {
+    #[serde(rename = "$schema")]
+    pub schema: String,
+    #[serde(rename = "$version")]
+    pub version: u32,
+    pub logging: bool,
+    pub log_steam_http: bool,
+    pub default_app_status: String,
+    pub override_app_status: HashMap<String, String>,
+    pub override_dlc_status: HashMap<String, String>,
+    pub auto_inject_inventory: bool,
+    pub extra_inventory_items: Vec<u32>,
+    pub extra_dlcs: HashMap<String, serde_json::Value>,
+}
+
+impl Default for SmokeAPIConfig {
+    fn default() -> Self {
+        Self {
+            schema: "https://raw.githubusercontent.com/acidicoala/SmokeAPI/refs/tags/v4.0.0/res/SmokeAPI.schema.json".to_string(),
+            version: 4,
+            logging: false,
+            log_steam_http: false,
+            default_app_status: "unlocked".to_string(),
+            override_app_status: HashMap::new(),
+            override_dlc_status: HashMap::new(),
+            auto_inject_inventory: true,
+            extra_inventory_items: Vec::new(),
+            extra_dlcs: HashMap::new(),
+        }
+    }
+}
+
+// Read SmokeAPI config from a game directory
+// Returns None if the config doesn't exist
+pub fn read_config(game_path: &str) -> Result<Option<SmokeAPIConfig>, String> {
+    info!("Reading SmokeAPI config from: {}", game_path);
+
+    // Find the SmokeAPI DLL location in the game directory
+    let config_path = find_smokeapi_config_path(game_path)?;
+
+    if !config_path.exists() {
+        info!("No SmokeAPI config found at: {}", config_path.display());
+        return Ok(None);
+    }
+
+    let content = fs::read_to_string(&config_path)
+        .map_err(|e| format!("Failed to read SmokeAPI config: {}", e))?;
+
+    let config: SmokeAPIConfig = serde_json::from_str(&content)
+        .map_err(|e| format!("Failed to parse SmokeAPI config: {}", e))?;
+
+    info!("Successfully read SmokeAPI config");
+    Ok(Some(config))
+}
+
+// Write SmokeAPI config to a game directory
+pub fn write_config(game_path: &str, config: &SmokeAPIConfig) -> Result<(), String> {
+    info!("Writing SmokeAPI config to: {}", game_path);
+
+    let config_path = find_smokeapi_config_path(game_path)?;
+
+    let content = serde_json::to_string_pretty(config)
+        .map_err(|e| format!("Failed to serialize SmokeAPI config: {}", e))?;
+
+    fs::write(&config_path, content)
+        .map_err(|e| format!("Failed to write SmokeAPI config: {}", e))?;
+
+    info!("Successfully wrote SmokeAPI config to: {}", config_path.display());
+    Ok(())
+}
+
+// Delete SmokeAPI config from a game directory
+pub fn delete_config(game_path: &str) -> Result<(), String> {
+    info!("Deleting SmokeAPI config from: {}", game_path);
+
+    let config_path = find_smokeapi_config_path(game_path)?;
+
+    if config_path.exists() {
+        fs::remove_file(&config_path)
+            .map_err(|e| format!("Failed to delete SmokeAPI config: {}", e))?;
+        info!("Successfully deleted SmokeAPI config");
+    } else {
+        info!("No SmokeAPI config to delete");
+    }
+
+    Ok(())
+}
+
+// Find the path where SmokeAPI.config.json should be located
+// This is in the same directory as the SmokeAPI DLL files
+fn find_smokeapi_config_path(game_path: &str) -> Result<std::path::PathBuf, String> {
+    let game_path_obj = Path::new(game_path);
+
+    // Search for steam_api*.dll files with _o.dll backups (indicating SmokeAPI installation)
+    let mut smokeapi_dir: Option<std::path::PathBuf> = None;
+
+    // Use walkdir to search recursively
+    for entry in walkdir::WalkDir::new(game_path_obj)
+        .max_depth(5)
+        .into_iter()
+        .filter_map(Result::ok)
+    {
+        let path = entry.path();
+        let filename = path.file_name().unwrap_or_default().to_string_lossy();
+
+        // Look for steam_api*_o.dll (backup files created by SmokeAPI)
+        if filename.starts_with("steam_api") && filename.ends_with("_o.dll") {
+            smokeapi_dir = path.parent().map(|p| p.to_path_buf());
+            break;
+        }
+    }
+
+    // If we found a SmokeAPI directory, return the config path
+    if let Some(dir) = smokeapi_dir {
+        Ok(dir.join("SmokeAPI.config.json"))
+    } else {
+        // Fallback to game root directory
+        warn!("Could not find SmokeAPI DLL directory, using game root");
+        Ok(game_path_obj.join("SmokeAPI.config.json"))
+    }
+}

src-tauri/src/unlockers/smokeapi.rs

@@ -94,7 +94,7 @@ impl Unlocker for SmokeAPI {
         let mut archive =
             ZipArchive::new(file).map_err(|e| format!("Failed to read zip archive: {}", e))?;
 
-        // Extract all DLL files
+        // Extract both DLL files (for Proton) and .so files (for native Linux)
         for i in 0..archive.len() {
             let mut file = archive
                 .by_index(i)
@@ -102,8 +102,11 @@ impl Unlocker for SmokeAPI {
 
             let file_name = file.name();
 
-            // Only extract DLL files
-            if file_name.to_lowercase().ends_with(".dll") {
+            // Extract DLL files for Proton and .so files for native Linux
+            let should_extract = file_name.to_lowercase().ends_with(".dll") 
+                || file_name.to_lowercase().ends_with(".so");
+
+            if should_extract {
                 let output_path = version_dir.join(
                     Path::new(file_name)
                         .file_name()
@@ -127,17 +130,56 @@ impl Unlocker for SmokeAPI {
     }
 
     async fn install_to_game(game_path: &str, api_files_str: &str) -> Result<(), String> {
+        // Check if this is a native Linux game or Proton game
+        // Native games have empty api_files_str, Proton games have DLL paths
+        let is_native = api_files_str.is_empty();
+
+        if is_native {
+            Self::install_to_native_game(game_path).await
+        } else {
+            Self::install_to_proton_game(game_path, api_files_str).await
+        }
+    }
+
+    async fn uninstall_from_game(game_path: &str, api_files_str: &str) -> Result<(), String> {
+        // Check if this is a native Linux game or Proton game
+        let is_native = api_files_str.is_empty();
+
+        if is_native {
+            Self::uninstall_from_native_game(game_path).await
+        } else {
+            Self::uninstall_from_proton_game(game_path, api_files_str).await
+        }
+    }
+
+    fn name() -> &'static str {
+        "SmokeAPI"
+    }
+}
+
+impl SmokeAPI {
+    /// Install SmokeAPI to a Proton/Windows game
+    async fn install_to_proton_game(game_path: &str, api_files_str: &str) -> Result<(), String> {
         // Parse api_files from the context string (comma-separated)
         let api_files: Vec<String> = api_files_str.split(',').map(|s| s.to_string()).collect();
 
         info!(
-            "Installing SmokeAPI to {} for {} API files",
+            "Installing SmokeAPI (Proton) to {} for {} API files",
             game_path,
             api_files.len()
         );
 
         // Get the cached SmokeAPI DLLs
-        let cached_dlls = crate::cache::list_smokeapi_dlls()?;
+        let cached_files = crate::cache::list_smokeapi_files()?;
+        if cached_files.is_empty() {
+            return Err("No SmokeAPI files found in cache".to_string());
+        }
+
+        let cached_dlls: Vec<_> = cached_files
+            .iter()
+            .filter(|f| f.extension().and_then(|e| e.to_str()) == Some("dll"))
+            .collect();
+        
         if cached_dlls.is_empty() {
             return Err("No SmokeAPI DLLs found in cache".to_string());
         }
@@ -195,15 +237,77 @@ impl Unlocker for SmokeAPI {
             );
         }
 
-        info!("SmokeAPI installation completed for: {}", game_path);
+        info!("SmokeAPI (Proton) installation completed for: {}", game_path);
         Ok(())
     }
 
-    async fn uninstall_from_game(game_path: &str, api_files_str: &str) -> Result<(), String> {
+    /// Install SmokeAPI to a native Linux game
+    async fn install_to_native_game(game_path: &str) -> Result<(), String> {
+        info!("Installing SmokeAPI (native) to {}", game_path);
+
+        // Detect game bitness
+        let bitness = crate::utils::bitness::detect_game_bitness(game_path)?;
+        info!("Detected game bitness: {:?}", bitness);
+
+        // Get the cached SmokeAPI files
+        let cached_files = crate::cache::list_smokeapi_files()?;
+        if cached_files.is_empty() {
+            return Err("No SmokeAPI files found in cache".to_string());
+        }
+
+        // Determine which .so file to use based on bitness
+        let target_so = match bitness {
+            crate::utils::bitness::Bitness::Bit32 => "libsmoke_api32.so",
+            crate::utils::bitness::Bitness::Bit64 => "libsmoke_api64.so",
+        };
+
+        // Find the matching .so file in cache
+        let matching_so = cached_files
+            .iter()
+            .find(|file| {
+                file.file_name()
+                    .unwrap_or_default()
+                    .to_string_lossy()
+                    == target_so
+            })
+            .ok_or_else(|| format!("No matching {} found in cache", target_so))?;
+
+        let game_path_obj = Path::new(game_path);
+
+        // Look for libsteam_api.so in the game directory (scan up to depth 3)
+        let libsteam_path = Self::find_libsteam_api(game_path_obj)?;
+        
+        info!("Found libsteam_api.so at: {}", libsteam_path.display());
+
+        // Create backup of original libsteam_api.so
+        let backup_path = libsteam_path.with_file_name("libsteam_api_o.so");
+        
+        // Only backup if not already backed up
+        if !backup_path.exists() && libsteam_path.exists() {
+            fs::copy(&libsteam_path, &backup_path)
+                .map_err(|e| format!("Failed to backup libsteam_api.so: {}", e))?;
+            info!("Created backup: {}", backup_path.display());
+        }
+
+        // Replace libsteam_api.so with SmokeAPI's libsmoke_api.so
+        fs::copy(matching_so, &libsteam_path)
+            .map_err(|e| format!("Failed to replace libsteam_api.so: {}", e))?;
+
+        info!(
+            "Replaced libsteam_api.so with {}",
+            target_so
+        );
+
+        info!("SmokeAPI (native) installation completed for: {}", game_path);
+        Ok(())
+    }
+
+    /// Uninstall SmokeAPI from a Proton/Windows game
+    async fn uninstall_from_proton_game(game_path: &str, api_files_str: &str) -> Result<(), String> {
         // Parse api_files from the context string (comma-separated)
         let api_files: Vec<String> = api_files_str.split(',').map(|s| s.to_string()).collect();
 
-        info!("Uninstalling SmokeAPI from: {}", game_path);
+        info!("Uninstalling SmokeAPI (Proton) from: {}", game_path);
 
         for api_file in &api_files {
             let api_path = Path::new(game_path).join(api_file);
@@ -250,11 +354,79 @@ impl Unlocker for SmokeAPI {
             }
         }
 
-        info!("SmokeAPI uninstallation completed for: {}", game_path);
+        info!("SmokeAPI (Proton) uninstallation completed for: {}", game_path);
         Ok(())
     }
 
-    fn name() -> &'static str {
-        "SmokeAPI"
+    /// Uninstall SmokeAPI from a native Linux game
+    async fn uninstall_from_native_game(game_path: &str) -> Result<(), String> {
+        info!("Uninstalling SmokeAPI (native) from: {}", game_path);
+
+        let game_path_obj = Path::new(game_path);
+
+        // Look for libsteam_api.so (which is actually our SmokeAPI now)
+        let libsteam_path = match Self::find_libsteam_api(game_path_obj) {
+            Ok(path) => path,
+            Err(_) => {
+                warn!("libsteam_api.so not found, nothing to uninstall");
+                return Ok(());
+            }
+        };
+
+        // Look for backup
+        let backup_path = libsteam_path.with_file_name("libsteam_api_o.so");
+
+        if backup_path.exists() {
+            // Remove the SmokeAPI version
+            if libsteam_path.exists() {
+                match fs::remove_file(&libsteam_path) {
+                    Ok(_) => info!("Removed SmokeAPI version: {}", libsteam_path.display()),
+                    Err(e) => warn!("Failed to remove SmokeAPI file: {}", e),
+                }
+            }
+
+            // Restore the original file
+            match fs::rename(&backup_path, &libsteam_path) {
+                Ok(_) => info!("Restored original libsteam_api.so"),
+                Err(e) => {
+                    warn!("Failed to restore original file: {}", e);
+                    // Try to copy instead if rename fails
+                    if let Err(copy_err) = fs::copy(&backup_path, &libsteam_path)
+                        .and_then(|_| fs::remove_file(&backup_path))
+                    {
+                        error!("Failed to copy backup file: {}", copy_err);
+                    }
+                }
+            }
+        } else {
+            warn!("No backup found (libsteam_api_o.so), cannot restore original");
+        }
+
+        info!("SmokeAPI (native) uninstallation completed for: {}", game_path);
+        Ok(())
+    }
+
+    /// Find libsteam_api.so in the game directory
+    fn find_libsteam_api(game_path: &Path) -> Result<std::path::PathBuf, String> {
+        use walkdir::WalkDir;
+
+        // Scan for libsteam_api.so (some games place it several subdirectories deep)
+        for entry in WalkDir::new(game_path)
+            .max_depth(8)
+            .into_iter()
+            .filter_map(Result::ok)
+        {
+            let path = entry.path();
+            if !path.is_file() {
+                continue;
+            }
+
+            let filename = path.file_name().unwrap_or_default().to_string_lossy();
+            if filename == "libsteam_api.so" {
+                return Ok(path.to_path_buf());
+            }
+        }
+
+        Err("libsteam_api.so not found in game directory".to_string())
     }
 }

src-tauri/src/utils/bitness.rs

@@ -0,0 +1,204 @@
+use log::{debug, info, warn};
+use std::fs;
+use std::path::Path;
+use walkdir::WalkDir;
+
+/// Represents the bitness of a binary
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Bitness {
+    Bit32,
+    Bit64,
+}
+
+/// Detect the bitness of a Linux Binary by reading ELF header
+/// ELF format: https://en.wikipedia.org/wiki/Executable_and_Linkable_Format
+fn detect_binary_bitness(file_path: &Path) -> Option<Bitness> {
+    use std::io::Read;
+
+    // Only read first 5 bytes
+    let mut file = fs::File::open(file_path).ok()?;
+    let mut bytes = [0u8; 5];
+
+    // Read exactly 5 bytes or fail
+    if file.read_exact(&mut bytes).is_err() {
+        return None;
+    }
+
+    // Check for ELF magic number (0x7F 'E' 'L' 'F')
+    if &bytes[0..4] != b"\x7FELF" {
+        return None;
+    }
+
+    // Byte 4 (EI_CLASS) indicates 32-bit or 64-bit
+    // 1 = ELFCLASS32 (32-bit)
+    // 2 = ELFCLASS64 (64-bit)
+    match bytes[4] {
+        1 => Some(Bitness::Bit32),
+        2 => Some(Bitness::Bit64),
+        _ => None,
+    }
+}
+
+/// Scan game directory for Linux binaries and determine bitness
+/// Returns the detected bitness, prioritizing the main game executable
+pub fn detect_game_bitness(game_path: &str) -> Result<Bitness, String> {
+    info!("Detecting bitness for game at: {}", game_path);
+
+    let game_path_obj = Path::new(game_path);
+    if !game_path_obj.exists() {
+        return Err("Game path does not exist".to_string());
+    }
+
+    // Directories to skip for performance
+    let skip_dirs = [
+        "videos",
+        "video",
+        "movies",
+        "movie",
+        "sound",
+        "sounds",
+        "audio",
+        "textures",
+        "music",
+        "localization",
+        "shaders",
+        "logs",
+        "assets",
+        "_CommonRedist",
+        "data",
+        "Data",
+        "Docs",
+        "docs",
+        "screenshots",
+        "Screenshots",
+        "saves",
+        "Saves",
+        "mods",
+        "Mods",
+        "maps",
+        "Maps",
+    ];
+
+    // Limit scan depth to avoid deep recursion
+    const MAX_DEPTH: usize = 3;
+
+    // Stop after finding reasonable confidence (10 binaries)
+    const CONFIDENCE_THRESHOLD: usize = 10;
+
+    let mut bit64_binaries = Vec::new();
+    let mut bit32_binaries = Vec::new();
+
+    #[cfg(unix)]
+    use std::os::unix::fs::PermissionsExt;
+
+    // Scan for Linux binaries
+    for entry in WalkDir::new(game_path_obj)
+        .max_depth(MAX_DEPTH)
+        .follow_links(false)
+        .into_iter()
+        .filter_entry(|e| {
+            if e.file_type().is_dir() {
+                let dir_name = e.file_name().to_string_lossy().to_lowercase();
+                !skip_dirs.iter().any(|&skip| dir_name.contains(skip))
+            } else {
+                true
+            }
+        })
+        .filter_map(Result::ok)
+    {
+        // Early termination when we have high confidence
+        if bit64_binaries.len() >= CONFIDENCE_THRESHOLD || bit32_binaries.len() >= CONFIDENCE_THRESHOLD {
+            debug!("Reached confidence threshold, stopping scan early");
+            break;
+        }
+
+        let path = entry.path();
+
+        // Only check files
+        if !path.is_file() {
+            continue;
+        }
+
+        // Skip non-binary files early for performance
+        let filename = path.file_name().unwrap_or_default().to_string_lossy();
+        
+        // Check for common Linux executable extensions or shared libraries
+        let has_binary_extension = filename.ends_with(".x86")
+            || filename.ends_with(".x86_64")
+            || filename.ends_with(".bin")
+            || filename.ends_with(".so")
+            || filename.contains(".so.")
+            || filename.starts_with("lib");
+
+        // Check if file is executable
+        let is_executable = {
+            {
+                // Get metadata once and check both extension and permissions
+                if let Ok(metadata) = fs::metadata(path) {
+                    let permissions = metadata.permissions();
+                    let executable = permissions.mode() & 0o111 != 0;
+
+                    // Skip files that are neither executable nor have binary extensions
+                    executable || has_binary_extension
+                } else {
+                    // If we can't read metadata, only proceed if it has binary extension
+                    has_binary_extension
+                }
+            }
+        };
+
+        if !is_executable {
+            continue;
+        }
+
+        // Detect bitness
+        if let Some(bitness) = detect_binary_bitness(path) {
+            debug!("Found {:?} binary: {}", bitness, path.display());
+
+            match bitness {
+                Bitness::Bit64 => {
+                    bit64_binaries.push(path.to_path_buf());
+
+                    // If we find libsteam_api.so and it's 64-bit, we can be very confident
+                    if filename == "libsteam_api.so" {
+                        info!("Found 64-bit libsteam_api.so");
+                        return Ok(Bitness::Bit64);
+                    }
+                },
+                Bitness::Bit32 => {
+                    bit32_binaries.push(path.to_path_buf());
+
+                    // If we find libsteam_api.so and it's 32-bit, we can be very confident
+                    if filename == "libsteam_api.so" {
+                        info!("Found 32-bit libsteam_api.so");
+                        return Ok(Bitness::Bit32);
+                    }
+                },
+            }
+        }
+    }
+
+    // Decision logic: prioritize finding the main game executable
+    // 1. If we found any 64-bit binaries and no 32-bit, it's 64-bit
+    // 2. If we found any 32-bit binaries and no 64-bit, it's 32-bit
+    // 3. If we found both, prefer 64-bit (modern games are usually 64-bit)
+    // 4. If we found neither, return an error
+
+    if !bit64_binaries.is_empty() && bit32_binaries.is_empty() {
+        info!("Detected 64-bit game (Only 64-bit binaries found)");
+        Ok(Bitness::Bit64)
+    } else if !bit32_binaries.is_empty() && bit64_binaries.is_empty() {
+        info!("Detected 32-bit game (Only 32-bit binaries found)");
+        Ok(Bitness::Bit32)
+    } else if !bit64_binaries.is_empty() && !bit32_binaries.is_empty() {
+        warn!(
+            "Found both 32-bit and 64-bit binaries, defaulting to 64-bit. 32-bit: {}, 64-bit: {}",
+            bit32_binaries.len(),
+            bit64_binaries.len()
+        );
+        info!("Detected 64-bit game (mixed binaries, defaulting to 64-bit)");
+        Ok(Bitness::Bit64)
+    } else {
+        Err("Could not detect game bitness: no Linux binaries found".to_string())
+    }
+}

src-tauri/src/utils/mod.rs

@@ -0,0 +1 @@
+pub mod bitness;

src-tauri/tauri.conf.json

@@ -19,7 +19,7 @@
   },
   "productName": "Creamlinux",
   "mainBinaryName": "creamlinux",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "identifier": "com.creamlinux.dev",
   "app": {
     "withGlobalTauri": false,

src/App.tsx

@@ -1,13 +1,28 @@
 import { useState } from 'react'
+import { invoke } from '@tauri-apps/api/core'
 import { useAppContext } from '@/contexts/useAppContext'
-import { useAppLogic } from '@/hooks'
+import { useAppLogic, useConflictDetection, useDisclaimer } from '@/hooks'
 import './styles/main.scss'
 
 // Layout components
-import { Header, Sidebar, InitialLoadingScreen, ErrorBoundary, UpdateScreen, AnimatedBackground } from '@/components/layout'
+import {
+  Header,
+  Sidebar,
+  InitialLoadingScreen,
+  ErrorBoundary,
+  UpdateScreen,
+  AnimatedBackground,
+} from '@/components/layout'
 
 // Dialog components
-import { ProgressDialog, DlcSelectionDialog, SettingsDialog } from '@/components/dialogs'
+import {
+  ProgressDialog,
+  DlcSelectionDialog,
+  SettingsDialog,
+  ConflictDialog,
+  DisclaimerDialog,
+  UnlockerSelectionDialog,
+} from '@/components/dialogs'
 
 // Game components
 import { GameList } from '@/components/games'
@@ -17,6 +32,9 @@ import { GameList } from '@/components/games'
  */
 function App() {
   const [updateComplete, setUpdateComplete] = useState(false)
+
+  const { showDisclaimer, handleDisclaimerClose } = useDisclaimer()
+
   // Get application logic from hook
   const {
     filter,
@@ -33,6 +51,7 @@ function App() {
 
   // Get action handlers from context
   const {
+    games,
     dlcDialog,
     handleDlcDialogClose,
     handleProgressDialogClose,
@@ -40,11 +59,46 @@ function App() {
     handleGameAction,
     handleDlcConfirm,
     handleGameEdit,
+    handleUpdateDlcs,
     settingsDialog,
     handleSettingsOpen,
     handleSettingsClose,
+    handleSmokeAPISettingsOpen,
+    handleOpenRating,
+    reportingEnabled,
+    showToast,
+    unlockerSelectionDialog,
+    handleSelectCreamLinux,
+    handleSelectSmokeAPI,
+    closeUnlockerDialog,
   } = useAppContext()
 
+  // Conflict detection
+  const { conflicts, showDialog, resolveConflict, closeDialog } =
+    useConflictDetection(games)
+
+  // Handle conflict resolution
+  const handleConflictResolve = async (
+    gameId: string,
+    conflictType: 'cream-to-proton' | 'smoke-to-native'
+  ) => {
+    try {
+      // Invoke backend to resolve the conflict
+      await invoke('resolve_platform_conflict', {
+        gameId,
+        conflictType,
+      })
+
+      // Remove from UI
+      resolveConflict(gameId, conflictType)
+
+      showToast('Conflict resolved successfully', 'success')
+    } catch (error) {
+      console.error('Error resolving conflict:', error)
+      showToast('Failed to resolve conflict', 'error')
+    }
+  }
+
   // Show update screen first
   if (!updateComplete) {
     return <UpdateScreen onComplete={() => setUpdateComplete(true)} />
@@ -71,7 +125,11 @@ function App() {
 
         <div className="main-content">
           {/* Sidebar for filtering */}
-          <Sidebar setFilter={setFilter} currentFilter={filter} onSettingsClick={handleSettingsOpen} />
+          <Sidebar
+            setFilter={setFilter}
+            currentFilter={filter}
+            onSettingsClick={handleSettingsOpen}
+          />
 
           {/* Show error or game list */}
           {error ? (
@@ -86,6 +144,9 @@ function App() {
               isLoading={isLoading}
               onAction={handleGameAction}
               onEdit={handleGameEdit}
+              onSmokeAPISettings={handleSmokeAPISettingsOpen}
+              onRate={handleOpenRating}
+              reportingEnabled={reportingEnabled}
             />
           )}
         </div>
@@ -105,20 +166,43 @@ function App() {
         <DlcSelectionDialog
           visible={dlcDialog.visible}
           gameTitle={dlcDialog.gameTitle}
+          gameId={dlcDialog.gameId}
           dlcs={dlcDialog.dlcs}
           isLoading={dlcDialog.isLoading}
           isEditMode={dlcDialog.isEditMode}
+          isUpdating={dlcDialog.isUpdating}
+          updateAttempted={dlcDialog.updateAttempted}
           loadingProgress={dlcDialog.progress}
           estimatedTimeLeft={dlcDialog.timeLeft}
+          newDlcsCount={dlcDialog.newDlcsCount}
           onClose={handleDlcDialogClose}
           onConfirm={handleDlcConfirm}
+          onUpdate={handleUpdateDlcs}
         />
 
         {/* Settings Dialog */}
-        <SettingsDialog 
-          visible ={settingsDialog.visible}
-          onClose={handleSettingsClose}
+        <SettingsDialog visible={settingsDialog.visible} onClose={handleSettingsClose} />
+
+        {/* Conflict Detection Dialog */}
+        <ConflictDialog
+          visible={showDialog}
+          conflicts={conflicts}
+          onResolve={handleConflictResolve}
+          onClose={closeDialog}
         />
+
+        {/* Unlocker Selection Dialog */}
+        <UnlockerSelectionDialog
+          visible={unlockerSelectionDialog.visible}
+          gameId={unlockerSelectionDialog.gameId}
+          gameTitle={unlockerSelectionDialog.gameTitle || ''}
+          onClose={closeUnlockerDialog}
+          onSelectCreamLinux={handleSelectCreamLinux}
+          onSelectSmokeAPI={handleSelectSmokeAPI}
+        />
+
+        {/* Disclaimer Dialog - Shows AFTER everything is loaded */}
+        <DisclaimerDialog visible={showDisclaimer} onClose={handleDisclaimerClose} />
       </div>
     </ErrorBoundary>
   )

src/components/buttons/ActionButton.tsx

@@ -3,7 +3,7 @@ import Button, { ButtonVariant } from '../buttons/Button'
 import { Icon, trash, download } from '@/components/icons'
 
 // Define available action types
-export type ActionType = 'install_cream' | 'uninstall_cream' | 'install_smoke' | 'uninstall_smoke'
+export type ActionType = 'install_cream' | 'uninstall_cream' | 'install_smoke' | 'uninstall_smoke' | 'install_unlocker'
 
 interface ActionButtonProps {
   action: ActionType
@@ -18,7 +18,6 @@ interface ActionButtonProps {
  * Specialized button for game installation actions
  */
 const ActionButton: FC<ActionButtonProps> = ({
-  action,
   isInstalled,
   isWorking,
   onClick,
@@ -29,10 +28,7 @@ const ActionButton: FC<ActionButtonProps> = ({
   const getButtonText = () => {
     if (isWorking) return 'Working...'
 
-    const isCream = action.includes('cream')
-    const product = isCream ? 'CreamLinux' : 'SmokeAPI'
-
-    return isInstalled ? `Uninstall ${product}` : `Install ${product}`
+    return isInstalled ? 'Uninstall' : 'Install'
   }
 
   // Map to button variant

src/components/common/Dropdown.tsx

@@ -0,0 +1,97 @@
+import { useState, useRef, useEffect } from 'react'
+import { Icon, arrowUp } from '@/components/icons'
+
+export interface DropdownOption<T = string> {
+  value: T
+  label:  string
+}
+
+interface DropdownProps<T = string> {
+  label: string
+  description?: string
+  value: T
+  options: DropdownOption<T>[]
+  onChange: (value: T) => void
+  disabled?: boolean
+  className?: string
+}
+
+/**
+ * Dropdown component for selecting from a list of options
+ */
+const Dropdown = <T extends string | number | boolean>({
+  label,
+  description,
+  value,
+  options,
+  onChange,
+  disabled = false,
+  className = '',
+}: DropdownProps<T>) => {
+  const [isOpen, setIsOpen] = useState(false)
+  const dropdownRef = useRef<HTMLDivElement>(null)
+
+  // Close dropdown when clicking outside
+  useEffect(() => {
+    const handleClickOutside = (event: MouseEvent) => {
+      if (dropdownRef.current && !dropdownRef.current.contains(event.target as Node)) {
+        setIsOpen(false)
+      }
+    }
+
+    if (isOpen) {
+      document.addEventListener('mousedown', handleClickOutside)
+      return () => document.removeEventListener('mousedown', handleClickOutside)
+    }
+  }, [isOpen])
+
+  const selectedOption = options.find((opt) => opt.value === value)
+
+  const handleSelect = (optionValue: T) => {
+    onChange(optionValue)
+    setIsOpen(false)
+  }
+
+  return (
+    <div className={`dropdown-container ${className}`}>
+      <div className="dropdown-label-container">
+        <label className="dropdown-label">{label}</label>
+        {description && <p className="dropdown-description">{description}</p>}
+      </div>
+
+      <div className={`dropdown ${disabled ? 'disabled' : ''}`} ref={dropdownRef}>
+        <button
+          type="button"
+          className="dropdown-trigger"
+          onClick={() => !disabled && setIsOpen(!isOpen)}
+          disabled={disabled}
+        >
+          <span className="dropdown-value">{selectedOption?.label || 'Select...'}</span>
+          <Icon
+            name={arrowUp}
+            variant="solid"
+            size="sm"
+            className={`dropdown-icon ${isOpen ? 'open' : ''}`}
+          />
+        </button>
+
+        {isOpen && !disabled && (
+          <div className="dropdown-menu">
+            {options.map((option) => (
+              <button
+                key={String(option.value)}
+                type="button"
+                className={`dropdown-option ${option.value === value ? 'selected' : ''}`}
+                onClick={() => handleSelect(option.value)}
+              >
+                {option.label}
+              </button>
+            ))}
+          </div>
+        )}
+      </div>
+    </div>
+  )
+}
+
+export default Dropdown

src/components/common/VotesDisplay.tsx

@@ -0,0 +1,47 @@
+import React from 'react'
+
+export interface GameVotes {
+  unlocker: string
+  success: number
+  fail: number
+}
+
+interface VotesDisplayProps {
+  votes: GameVotes | null
+}
+
+/**
+ * Compact vote bar shown inside the unlocker selection dialog.
+ * Shows a green/red progress bar with a label, or "No votes yet" when empty.
+ */
+const VotesDisplay: React.FC<VotesDisplayProps> = ({ votes }) => {
+  if (!votes || (votes.success === 0 && votes.fail === 0)) {
+    return (
+      <div className="unlocker-votes">
+        <span className="votes-label votes-label--none">No votes yet</span>
+      </div>
+    )
+  }
+
+  const total = votes.success + votes.fail
+  const pct = Math.round((votes.success / total) * 100)
+
+  const labelClass =
+    pct >= 70 ? 'votes-label--positive' : pct >= 40 ? '' : 'votes-label--negative'
+
+  return (
+    <div
+      className="unlocker-votes"
+      title={`${votes.success} worked · ${votes.fail} didn't work`}
+    >
+      <div className="votes-bar-wrap">
+        <div className="votes-bar-fill" style={{ width: `${pct}%` }} />
+      </div>
+      <span className={`votes-label ${labelClass}`}>
+        {pct}% working ({total})
+      </span>
+    </div>
+  )
+}
+
+export default VotesDisplay

src/components/common/index.ts

@@ -1,4 +1,8 @@
 export { default as LoadingIndicator } from './LoadingIndicator'
 export { default as ProgressBar } from './ProgressBar'
+export { default as Dropdown } from './Dropdown'
+export { default as VotesDisplay } from './VotesDisplay'
 
 export type { LoadingSize, LoadingType } from './LoadingIndicator'
+export type { DropdownOption } from './Dropdown'
+export type { GameVotes } from './VotesDisplay'

src/components/dialogs/AddDlcDialog.tsx

@@ -0,0 +1,93 @@
+import { useState, useEffect } from 'react'
+import Dialog from './Dialog'
+import DialogHeader from './DialogHeader'
+import DialogBody from './DialogBody'
+import DialogFooter from './DialogFooter'
+import DialogActions from './DialogActions'
+import { Button } from '@/components/buttons'
+import { DlcInfo } from '@/types'
+
+export interface AddDlcDialogProps {
+  visible: boolean
+  onClose: () => void
+  onAdd: (dlc: DlcInfo) => void
+  existingIds: Set<string>
+}
+
+/**
+ * Add DLC Manually dialog
+ * Allows users to manually enter a DLC ID and name when it is
+ * missing from the Steam API and cannot be fetched automatically
+ */
+const AddDlcDialog = ({ visible, onClose, onAdd, existingIds }: AddDlcDialogProps) => {
+  const [id, setId] = useState('')
+  const [name, setName] = useState('')
+  const [error, setError] = useState('')
+
+  // Reset form state when dialog closes
+  useEffect(() => {
+    if (!visible) {
+      setId('')
+      setName('')
+      setError('')
+    }
+  }, [visible])
+
+  // Validate inputs and add the DLC to the list
+  const handleSubmit = () => {
+    const trimmedId = id.trim()
+    const trimmedName = name.trim()
+
+    if (!trimmedId) return setError('DLC ID is required.')
+    if (!/^\d+$/.test(trimmedId)) return setError('DLC ID must be a number.')
+    if (existingIds.has(trimmedId)) return setError('A DLC with this ID already exists.')
+    if (!trimmedName) return setError('DLC name is required.')
+
+    onAdd({ appid: trimmedId, name: trimmedName, enabled: true })
+    onClose()
+  }
+
+  return (
+    <Dialog visible={visible} onClose={onClose} size="small">
+      <DialogHeader onClose={onClose}>
+        <h3>Add DLC Manually</h3>
+      </DialogHeader>
+      <DialogBody>
+        <div className="add-dlc-form">
+          <div className="add-dlc-field">
+            <label className="add-dlc-label">DLC ID</label>
+            <input
+              type="text"
+              className="add-dlc-input"
+              placeholder="e.g. 1234560"
+              value={id}
+              onChange={(e) => { setId(e.target.value); setError('') }}
+              onKeyDown={(e) => e.key === 'Enter' && handleSubmit()}
+              autoFocus
+            />
+          </div>
+          <div className="add-dlc-field">
+            <label className="add-dlc-label">DLC Name</label>
+            <input
+              type="text"
+              className="add-dlc-input"
+              placeholder="e.g. Expansion - My DLC"
+              value={name}
+              onChange={(e) => { setName(e.target.value); setError('') }}
+              onKeyDown={(e) => e.key === 'Enter' && handleSubmit()}
+            />
+          </div>
+          {error && <p className="add-dlc-error">{error}</p>}
+        </div>
+      </DialogBody>
+      <DialogFooter>
+        <DialogActions>
+          <Button variant="secondary" onClick={onClose}>Cancel</Button>
+          <Button variant="primary" onClick={handleSubmit}>Add DLC</Button>
+        </DialogActions>
+      </DialogFooter>
+    </Dialog>
+  )
+}
+
+export default AddDlcDialog

src/components/dialogs/ConflictDialog.tsx

@@ -0,0 +1,106 @@
+import React from 'react'
+import {
+  Dialog,
+  DialogHeader,
+  DialogBody,
+  DialogFooter,
+  DialogActions,
+} from '@/components/dialogs'
+import { Button } from '@/components/buttons'
+import { Icon, warning, info } from '@/components/icons'
+
+export interface Conflict {
+  gameId: string
+  gameTitle: string
+  type: 'cream-to-proton' | 'smoke-to-native'
+}
+
+export interface ConflictDialogProps {
+  visible: boolean
+  conflicts: Conflict[]
+  onResolve: (gameId: string, conflictType: 'cream-to-proton' | 'smoke-to-native') => void
+  onClose: () => void
+}
+
+/**
+ * Conflict Dialog component
+ * Shows all conflicts at once with individual resolve buttons
+ */
+const ConflictDialog: React.FC<ConflictDialogProps> = ({
+  visible,
+  conflicts,
+  onResolve,
+  onClose,
+}) => {
+  // Check if any CreamLinux conflicts exist
+  const hasCreamConflicts = conflicts.some((c) => c.type === 'cream-to-proton')
+
+  const getConflictDescription = (type: 'cream-to-proton' | 'smoke-to-native') => {
+    if (type === 'cream-to-proton') {
+      return 'Will remove existing unlocker files and restore the game to a clean state.'
+    } else {
+      return 'Will remove existing unlocker files and restore the game to a clean state.'
+    }
+  }
+
+  return (
+    <Dialog visible={visible} size="large" preventBackdropClose={true}>
+      <DialogHeader hideCloseButton={true}>
+        <div className="conflict-dialog-header">
+          <Icon name={warning} variant="solid" size="lg" />
+          <h3>Unlocker conflicts detected</h3>
+        </div>
+      </DialogHeader>
+
+      <DialogBody>
+        <div className="conflict-dialog-body">
+          <p className="conflict-intro">
+            Some games have conflicting unlocker states that need attention.
+          </p>
+
+          <div className="conflict-list">
+            {conflicts.map((conflict) => (
+              <div key={conflict.gameId} className="conflict-item">
+                <div className="conflict-info">
+                  <div className="conflict-icon">
+                    <Icon name={warning} variant="solid" size="md" />
+                  </div>
+                  <div className="conflict-details">
+                    <h4>{conflict.gameTitle}</h4>
+                    <p>{getConflictDescription(conflict.type)}</p>
+                  </div>
+                </div>
+                <Button
+                  variant="primary"
+                  onClick={() => onResolve(conflict.gameId, conflict.type)}
+                  className="conflict-resolve-btn"
+                >
+                  Resolve
+                </Button>
+              </div>
+            ))}
+          </div>
+        </div>
+      </DialogBody>
+
+      <DialogFooter>
+        {hasCreamConflicts && (
+          <div className="conflict-reminder">
+            <Icon name={info} variant="solid" size="md" />
+            <span>
+              Remember to remove <code>sh ./cream.sh %command%</code> from Steam launch options
+              after resolving CreamLinux conflicts.
+            </span>
+          </div>
+        )}
+        <DialogActions>
+          <Button variant="secondary" onClick={onClose}>
+            Close
+          </Button>
+        </DialogActions>
+      </DialogFooter>
+    </Dialog>
+  )
+}
+
+export default ConflictDialog

src/components/dialogs/DisclaimerDialog.tsx

@@ -0,0 +1,69 @@
+import {
+  Dialog,
+  DialogHeader,
+  DialogBody,
+  DialogFooter,
+  DialogActions,
+} from '@/components/dialogs'
+import { Button, AnimatedCheckbox } from '@/components/buttons'
+import { useState } from 'react'
+
+export interface DisclaimerDialogProps {
+  visible: boolean
+  onClose: (dontShowAgain: boolean) => void
+}
+
+/**
+ * Disclaimer dialog that appears on app startup
+ * Informs users that CreamLinux manages DLC IDs, not actual DLC files
+ */
+const DisclaimerDialog = ({ visible, onClose }: DisclaimerDialogProps) => {
+  const [dontShowAgain, setDontShowAgain] = useState(false)
+
+  const handleOkClick = () => {
+    onClose(dontShowAgain)
+  }
+
+  return (
+    <Dialog visible={visible} onClose={() => onClose(false)} size="medium" preventBackdropClose>
+        <DialogHeader hideCloseButton={true}>
+          <div className="disclaimer-header">
+            <h3>Important Notice</h3>
+          </div>
+      </DialogHeader>
+
+      <DialogBody>
+        <div className="disclaimer-content">
+          <p>
+            <strong>CreamLinux Installer</strong> does not install any DLC content files.
+          </p>
+          <p>
+            This application manages the <strong>DLC IDs</strong> associated with DLCs you want to
+            use. You must obtain the actual DLC files separately.
+          </p>
+          <p>
+            This tool only configures which DLC IDs are recognized by the game unlockers
+            (CreamLinux and SmokeAPI).
+          </p>
+        </div>
+      </DialogBody>
+
+      <DialogFooter>
+        <DialogActions>
+          <div className="disclaimer-footer">
+            <AnimatedCheckbox
+              checked={dontShowAgain}
+              onChange={() => setDontShowAgain(!dontShowAgain)}
+              label="Don't show this disclaimer again"
+            />
+            <Button variant="primary" onClick={handleOkClick}>
+              OK
+            </Button>
+          </div>
+        </DialogActions>
+      </DialogFooter>
+    </Dialog>
+  )
+}
+
+export default DisclaimerDialog

src/components/dialogs/DlcSelectionDialog.tsx

@@ -4,19 +4,26 @@ import DialogHeader from './DialogHeader'
 import DialogBody from './DialogBody'
 import DialogFooter from './DialogFooter'
 import DialogActions from './DialogActions'
+import AddDlcDialog from './AddDlcDialog'
 import { Button, AnimatedCheckbox } from '@/components/buttons'
 import { DlcInfo } from '@/types'
+import { Icon, check, info } from '@/components/icons'
 
 export interface DlcSelectionDialogProps {
   visible: boolean
   gameTitle: string
+  gameId: string
   dlcs: DlcInfo[]
   onClose: () => void
   onConfirm: (selectedDlcs: DlcInfo[]) => void
+  onUpdate?: (gameId: string) => void
   isLoading: boolean
   isEditMode?: boolean
+  isUpdating?: boolean
+  updateAttempted?: boolean
   loadingProgress?: number
   estimatedTimeLeft?: string
+  newDlcsCount?: number
 }
 
 /**
@@ -27,19 +34,25 @@ export interface DlcSelectionDialogProps {
 const DlcSelectionDialog = ({
   visible,
   gameTitle,
+  gameId,
   dlcs,
   onClose,
   onConfirm,
+  onUpdate,
   isLoading,
   isEditMode = false,
+  isUpdating = false,
+  updateAttempted = false,
   loadingProgress = 0,
   estimatedTimeLeft = '',
+  newDlcsCount = 0,
 }: DlcSelectionDialogProps) => {
   // State for DLC management
   const [selectedDlcs, setSelectedDlcs] = useState<DlcInfo[]>([])
   const [searchQuery, setSearchQuery] = useState('')
   const [selectAll, setSelectAll] = useState(true)
   const [initialized, setInitialized] = useState(false)
+  const [showAddDlc, setShowAddDlc] = useState(false)
 
   // Reset dialog state when it opens or closes
   useEffect(() => {
@@ -115,6 +128,11 @@ const DlcSelectionDialog = ({
     )
   }, [selectAll])
 
+  // Add a manually-entered DLC to the list
+  const handleAddDlc = useCallback((dlc: DlcInfo) => {
+    setSelectedDlcs((prev) => [...prev, dlc])
+  }, [])
+
   // Submit selected DLCs to parent component
   const handleConfirm = useCallback(() => {
     // Create a deep copy to prevent reference issues
@@ -140,91 +158,140 @@ const DlcSelectionDialog = ({
   }
 
   return (
-    <Dialog visible={visible} onClose={onClose} size="large" preventBackdropClose={isLoading}>
-      <DialogHeader onClose={onClose} hideCloseButton={true}>
-        <h3>{dialogTitle}</h3>
-        <div className="dlc-game-info">
-          <span className="game-title">{gameTitle}</span>
-          <span className="dlc-count">
-            {selectedCount} of {selectedDlcs.length} DLCs selected
-            {getLoadingInfoText()}
-          </span>
-        </div>
-      </DialogHeader>
+    <>
+      <Dialog visible={visible} onClose={onClose} size="large" preventBackdropClose={isLoading}>
+        <DialogHeader onClose={onClose} hideCloseButton={true}>
+          <h3>{dialogTitle}</h3>
+          <div className="dlc-game-info">
+            <span className="game-title">{gameTitle}</span>
+            <span className="dlc-count">
+              {selectedCount} of {selectedDlcs.length} DLCs selected
+              {getLoadingInfoText()}
+            </span>
+          </div>
+        </DialogHeader>
 
-      <div className="dlc-dialog-search">
-        <input
-          type="text"
-          placeholder="Search DLCs..."
-          value={searchQuery}
-          onChange={(e) => setSearchQuery(e.target.value)}
-          className="dlc-search-input"
-        />
-        <div className="select-all-container">
-          <AnimatedCheckbox
-            checked={selectAll}
-            onChange={handleToggleSelectAll}
-            label="Select All"
+        <div className="dlc-dialog-search">
+          <input
+            type="text"
+            placeholder="Search DLCs..."
+            value={searchQuery}
+            onChange={(e) => setSearchQuery(e.target.value)}
+            className="dlc-search-input"
           />
-        </div>
-      </div>
-
-      {isLoading && loadingProgress > 0 && (
-        <div className="dlc-loading-progress">
-          <div className="progress-bar-container">
-            <div className="progress-bar" style={{ width: `${loadingProgress}%` }} />
-          </div>
-          <div className="loading-details">
-            <span>Loading DLCs: {loadingProgress}%</span>
-            {estimatedTimeLeft && (
-              <span className="time-left">Est. time left: {estimatedTimeLeft}</span>
-            )}
+          <div className="select-all-container">
+            <AnimatedCheckbox
+              checked={selectAll}
+              onChange={handleToggleSelectAll}
+              label="Select All"
+            />
           </div>
         </div>
-      )}
 
-      <DialogBody className="dlc-list-container">
-        {selectedDlcs.length > 0 ? (
-          <ul className="dlc-list">
-            {filteredDlcs.map((dlc) => (
-              <li key={dlc.appid} className="dlc-item">
-                <AnimatedCheckbox
-                  checked={dlc.enabled}
-                  onChange={() => handleToggleDlc(dlc.appid)}
-                  label={dlc.name}
-                  sublabel={`ID: ${dlc.appid}`}
-                />
-              </li>
-            ))}
-            {isLoading && (
-              <li className="dlc-item dlc-item-loading">
-                <div className="loading-pulse"></div>
-              </li>
-            )}
-          </ul>
-        ) : (
-          <div className="dlc-loading">
-            <div className="loading-spinner"></div>
-            <p>Loading DLC information...</p>
+        {(isLoading || isUpdating) && loadingProgress > 0 && (
+          <div className="dlc-loading-progress">
+            <div className="progress-bar-container">
+              <div className="progress-bar" style={{ width: `${loadingProgress}%` }} />
+            </div>
+            <div className="loading-details">
+              <span>{isUpdating ? 'Updating DLC list' : 'Loading DLCs'}: {loadingProgress}%</span>
+              {estimatedTimeLeft && (
+                <span className="time-left">Est. time left: {estimatedTimeLeft}</span>
+              )}
+            </div>
           </div>
         )}
-      </DialogBody>
 
-      <DialogFooter>
-        <DialogActions>
-          <Button
-            variant="secondary"
-            onClick={onClose}
-            disabled={isLoading && loadingProgress < 10}
-          >
-            Cancel
-          </Button>
-          <Button variant="primary" onClick={handleConfirm} disabled={isLoading}>
-            {actionButtonText}
-          </Button>
-        </DialogActions>
-      </DialogFooter>
-    </Dialog>
+        <DialogBody className="dlc-list-container">
+          {selectedDlcs.length > 0 ? (
+            <ul className="dlc-list">
+              {filteredDlcs.map((dlc) => (
+                <li key={dlc.appid} className="dlc-item">
+                  <AnimatedCheckbox
+                    checked={dlc.enabled}
+                    onChange={() => handleToggleDlc(dlc.appid)}
+                    label={dlc.name}
+                    sublabel={`ID: ${dlc.appid}`}
+                  />
+                </li>
+              ))}
+              {isLoading && (
+                <li className="dlc-item dlc-item-loading">
+                  <div className="loading-pulse"></div>
+                </li>
+              )}
+            </ul>
+          ) : (
+            <div className="dlc-loading">
+              <div className="loading-spinner"></div>
+              <p>Loading DLC information...</p>
+            </div>
+          )}
+        </DialogBody>
+
+        <DialogFooter>
+          {/* Show update results */}
+          {!isUpdating && !isLoading && isEditMode && updateAttempted && (
+            <>
+              {newDlcsCount > 0 && (
+                <div className="dlc-update-results dlc-update-success">
+                  <span className="update-message">
+                    <Icon name={check} size="md" variant="solid" className="dlc-update-icon-success"/> Found {newDlcsCount} new DLC{newDlcsCount > 1 ? 's' : ''}!
+                  </span>
+                </div>
+              )}
+              {newDlcsCount === 0 && (
+                <div className="dlc-update-results dlc-update-info">
+                  <span className="update-message">
+                    <Icon name={info} size="md" variant="solid" className="dlc-update-icon-info"/> No new DLCs found. Your list is up to date!
+                  </span>
+                </div>
+              )}
+            </>
+          )}
+
+          <DialogActions>
+            <Button
+              variant="secondary"
+              onClick={onClose}
+              disabled={(isLoading || isUpdating) && loadingProgress < 10}
+            >
+              Cancel
+            </Button>
+
+            <Button
+              variant="secondary"
+              onClick={() => setShowAddDlc(true)}
+              disabled={isLoading || isUpdating}
+            >
+              Add DLC Manually
+            </Button>
+
+            {/* Update button - only show in edit mode */}
+            {isEditMode && onUpdate && (
+              <Button
+                variant="warning"
+                onClick={() => onUpdate(gameId)}
+                disabled={isLoading || isUpdating}
+              >
+                {isUpdating ? 'Updating...' : 'Update DLC List'}
+              </Button>
+            )}
+
+            <Button variant="primary" onClick={handleConfirm} disabled={isLoading || isUpdating}>
+              {actionButtonText}
+            </Button>
+          </DialogActions>
+        </DialogFooter>
+      </Dialog>
+
+      <AddDlcDialog
+        visible={showAddDlc}
+        onClose={() => setShowAddDlc(false)}
+        onAdd={handleAddDlc}
+        existingIds={new Set(selectedDlcs.map((d) => d.appid))}
+      />
+    </>
   )
 }
 

src/components/dialogs/OptInDialog.tsx

@@ -0,0 +1,82 @@
+import React from 'react'
+import {
+  Dialog,
+  DialogHeader,
+  DialogBody,
+  DialogFooter,
+  DialogActions,
+} from '@/components/dialogs'
+import { Button } from '@/components/buttons'
+import { Icon, info } from '@/components/icons'
+
+interface OptInDialogProps {
+  visible: boolean
+  onAccept: () => void
+  onDecline: () => void
+}
+
+/**
+ * First-launch opt-in dialog for the compatibility reporting system.
+ * Shown once when the app fully starts. Does not close until the user makes
+ * an explicit choice.
+ */
+const OptInDialog: React.FC<OptInDialogProps> = ({ visible, onAccept, onDecline }) => {
+  return (
+    <Dialog visible={visible} onClose={() => {}} size="medium">
+      <DialogHeader onClose={() => {}} hideCloseButton={true}>
+        <h3>Help improve CreamLinux</h3>
+      </DialogHeader>
+
+      <DialogBody>
+        <div className="optin-content">
+
+          <p className="optin-intro">
+            CreamLinux can collect anonymous compatibility reports to help users know which
+            games work with CreamLinux and SmokeAPI before they install them.
+          </p>
+
+          <div className="optin-details">
+            <h4>What we collect</h4>
+            <ul>
+              <li>
+                <strong>A one-way anonymous hash</strong> derived from your machine ID, Steam
+                install path, and a locally-stored random salt. <em>This cannot be reversed
+                to identify you</em>, and even we cannot link it to your machine.
+              </li>
+              <li>The Steam App ID of the game you rated.</li>
+              <li>Which unlocker you used (CreamLinux or SmokeAPI).</li>
+              <li>Whether it worked or not.</li>
+            </ul>
+
+            <h4>What we do not collect</h4>
+            <ul>
+              <li>Your username, IP address, or any personally identifiable information.</li>
+            </ul>
+          </div>
+
+          <div className="optin-notice">
+            <Icon name={info} variant="solid" size="md" />
+            <span>
+              If you opt out, the local salt will be deleted and no data will ever be sent.
+              You will not be able to submit compatibility votes, but the app works fully
+              without this feature.
+            </span>
+          </div>
+        </div>
+      </DialogBody>
+
+      <DialogFooter>
+        <DialogActions>
+          <Button variant="secondary" onClick={onDecline}>
+            No thanks
+          </Button>
+          <Button variant="primary" onClick={onAccept}>
+            Enable reporting
+          </Button>
+        </DialogActions>
+      </DialogFooter>
+    </Dialog>
+  )
+}
+
+export default OptInDialog

src/components/dialogs/RatingDialog.tsx

@@ -0,0 +1,164 @@
+import React, { useEffect, useState } from 'react'
+import { invoke } from '@tauri-apps/api/core'
+import {
+  Dialog,
+  DialogHeader,
+  DialogBody,
+  DialogFooter,
+  DialogActions,
+} from '@/components/dialogs'
+import { Button } from '@/components/buttons'
+import { Icon, info } from '@/components/icons'
+
+interface LocalReport {
+  game_id: string
+  unlocker: string
+  worked: boolean
+}
+
+export interface RatingDialogProps {
+  visible: boolean
+  gameTitle: string
+  gameId: string
+  /** 'creamlinux' | 'smokeapi' – whichever is currently installed */
+  unlocker: 'creamlinux' | 'smokeapi'
+  onClose: () => void
+  onSubmit: (worked: boolean) => Promise<void>
+}
+
+const UNLOCKER_LABELS: Record<string, string> = {
+  creamlinux: 'CreamLinux',
+  smokeapi: 'SmokeAPI',
+}
+
+/**
+ * Per-game rating dialog. Submits exactly one report for the installed unlocker.
+ */
+const RatingDialog: React.FC<RatingDialogProps> = ({
+  visible,
+  gameTitle,
+  gameId,
+  unlocker,
+  onClose,
+  onSubmit,
+}) => {
+  const [submitting, setSubmitting] = useState(false)
+  const [submitted, setSubmitted] = useState(false)
+  // Which vote the user has already cast for this game+unlocker, if any
+  const [previousVote, setPreviousVote] = useState<boolean | null>(null)
+
+  useEffect(() => {
+    if (!visible) return
+
+    // Reset submit state each time the dialog opens
+    setSubmitted(false)
+
+    // Load the local reports to see if this game+unlocker has already been started
+    invoke<LocalReport[]>('get_local_reports')
+      .then((reports) => {
+        const existing = reports.find(
+          (r) => r.game_id === gameId && r.unlocker === unlocker
+        )
+        setPreviousVote(existing ? existing.worked : null)
+      })
+      .catch(() => setPreviousVote(null))
+  }, [visible, gameId, unlocker])
+
+  const handleSubmit = async (worked: boolean) => {
+    if (submitting || submitted) return
+    setSubmitting(true)
+    try {
+      await onSubmit(worked)
+      setSubmitted(true)
+    } finally {
+      setSubmitting(false)
+    }
+  }
+
+  const handleClose = () => {
+    setSubmitted(false)
+    onClose()
+  }
+
+  const label = UNLOCKER_LABELS[unlocker] ?? unlocker
+
+  // A button is "already chosen" if it matches the previous vote
+  const workedAlreadyChosen = previousVote === true
+  const brokenAlreadyChosen = previousVote === false
+
+  return (
+    <Dialog visible={visible} onClose={handleClose} size="small">
+      <DialogHeader onClose={handleClose} hideCloseButton={true}>
+        <h3>Submit rating</h3>
+      </DialogHeader>
+
+      <DialogBody>
+        {submitted ? (
+          <div className="rating-submitted">
+            <p>Thanks for your report! Your vote helps other users.</p>
+          </div>
+        ) : (
+          <div className="rating-content">
+            <p>
+              You have <strong>{label}</strong> installed for{' '}
+              <strong>{gameTitle}</strong>. Did it work?
+            </p>
+
+            {previousVote !== null && (
+              <p className="rating-subtext">
+                You previously voted <strong>{previousVote ? 'worked' : "didn't work"}</strong>.
+                You can change your vote below.
+              </p>
+            )}
+
+            {previousVote === null && (
+              <p className="rating-subtext">
+                Your rating is anonymous and helps other users know if{' '}
+                {label} works with this game.
+              </p>
+            )}
+
+            <div className="rating-buttons">
+              <Button
+                variant="success"
+                className={`rating-btn rating-btn--worked${workedAlreadyChosen ? ' rating-btn--active' : ''}`}
+                onClick={() => handleSubmit(true)}
+                disabled={submitting || workedAlreadyChosen}
+                title={workedAlreadyChosen ? 'Already voted' : undefined}
+                leftIcon={<Icon name="Check" variant="solid" size="sm" />}
+              >
+                It worked
+              </Button>
+
+              <Button
+                variant="danger"
+                className={`rating-btn rating-btn--broken${brokenAlreadyChosen ? ' rating-btn--active' : ''}`}
+                onClick={() => handleSubmit(false)}
+                disabled={submitting || brokenAlreadyChosen}
+                title={brokenAlreadyChosen ? 'Already voted' : undefined}
+                leftIcon={<Icon name="Close" variant="solid" size="sm" />}
+              >
+                Didn't work
+              </Button>
+            </div>
+
+            <div className="rating-notice">
+              <Icon name={info} variant="solid" size="md" />
+              <span>Only the result for {label} will be submitted.</span>
+            </div>
+          </div>
+        )}
+      </DialogBody>
+
+      <DialogFooter>
+        <DialogActions>
+          <Button variant="secondary" onClick={handleClose}>
+            {submitted ? 'Close' : 'Cancel'}
+          </Button>
+        </DialogActions>
+      </DialogFooter>
+    </Dialog>
+  )
+}
+
+export default RatingDialog

src/components/dialogs/ReminderDialog.tsx

@@ -0,0 +1,56 @@
+import React from 'react'
+import {
+  Dialog,
+  DialogHeader,
+  DialogBody,
+  DialogFooter,
+  DialogActions,
+} from '@/components/dialogs'
+import { Button } from '@/components/buttons'
+import { Icon, info } from '@/components/icons'
+
+export interface ReminderDialogProps {
+  visible: boolean
+  onClose: () => void
+}
+
+/**
+ * Reminder Dialog component
+ * Reminds users to remove Steam launch options after removing CreamLinux
+ */
+const ReminderDialog: React.FC<ReminderDialogProps> = ({ visible, onClose }) => {
+  return (
+    <Dialog visible={visible} onClose={onClose} size="small">
+      <DialogHeader onClose={onClose} hideCloseButton={true}>
+        <div className="reminder-dialog-header">
+          <Icon name={info} variant="solid" size="lg" />
+          <h3>Reminder</h3>
+        </div>
+      </DialogHeader>
+
+      <DialogBody>
+        <div className="reminder-dialog-body">
+          <p>
+            If you added a Steam launch option for CreamLinux, remember to remove it in Steam:
+          </p>
+          <ol className="reminder-steps">
+            <li>Right-click the game in Steam</li>
+            <li>Select "Properties"</li>
+            <li>Go to "Launch Options"</li>
+            <li>Remove the CreamLinux command</li>
+          </ol>
+        </div>
+      </DialogBody>
+
+      <DialogFooter>
+        <DialogActions>
+          <Button variant="primary" onClick={onClose}>
+            Got it
+          </Button>
+        </DialogActions>
+      </DialogFooter>
+    </Dialog>
+  )
+}
+
+export default ReminderDialog

src/components/dialogs/SettingsDialog.tsx

@@ -41,7 +41,7 @@ const SettingsDialog: React.FC<SettingsDialogProps> = ({ visible, onClose }) =>
     <Dialog visible={visible} onClose={onClose} size="medium">
       <DialogHeader onClose={onClose} hideCloseButton={true}>
         <div className="settings-header">
-          <Icon name={settings} variant="solid" size="md" />
+          {/*<Icon name={settings} variant="solid" size="md" />*/}
           <h3>Settings</h3>
         </div>
       </DialogHeader>

src/components/dialogs/SmokeAPISettingsDialog.tsx

@@ -0,0 +1,228 @@
+import { useState, useEffect, useCallback } from 'react'
+import { invoke } from '@tauri-apps/api/core'
+import {
+  Dialog,
+  DialogHeader,
+  DialogBody,
+  DialogFooter,
+  DialogActions,
+} from '@/components/dialogs'
+import { Button, AnimatedCheckbox } from '@/components/buttons'
+import { Dropdown, DropdownOption } from '@/components/common'
+//import { Icon, settings } from '@/components/icons'
+
+interface SmokeAPIConfig {
+  $schema: string
+  $version: number
+  logging: boolean
+  log_steam_http: boolean
+  default_app_status: 'unlocked' | 'locked' | 'original'
+  override_app_status: Record<string, string>
+  override_dlc_status: Record<string, string>
+  auto_inject_inventory: boolean
+  extra_inventory_items: number[]
+  extra_dlcs: Record<string, unknown>
+}
+
+interface SmokeAPISettingsDialogProps {
+  visible: boolean
+  onClose: () => void
+  gamePath: string
+  gameTitle: string
+}
+
+const DEFAULT_CONFIG: SmokeAPIConfig = {
+  $schema:
+    'https://raw.githubusercontent.com/acidicoala/SmokeAPI/refs/tags/v4.0.0/res/SmokeAPI.schema.json',
+  $version: 4,
+  logging: false,
+  log_steam_http: false,
+  default_app_status: 'unlocked',
+  override_app_status: {},
+  override_dlc_status: {},
+  auto_inject_inventory: true,
+  extra_inventory_items: [],
+  extra_dlcs: {},
+}
+
+const APP_STATUS_OPTIONS: DropdownOption<'unlocked' | 'locked' | 'original'>[] = [
+  { value: 'unlocked', label: 'Unlocked' },
+  { value: 'locked', label: 'Locked' },
+  { value: 'original', label: 'Original' },
+]
+
+/**
+ * SmokeAPI Settings Dialog
+ * Allows configuration of SmokeAPI for a specific game
+ */
+const SmokeAPISettingsDialog = ({
+  visible,
+  onClose,
+  gamePath,
+  gameTitle,
+}: SmokeAPISettingsDialogProps) => {
+  const [enabled, setEnabled] = useState(false)
+  const [config, setConfig] = useState<SmokeAPIConfig>(DEFAULT_CONFIG)
+  const [isLoading, setIsLoading] = useState(false)
+  const [hasChanges, setHasChanges] = useState(false)
+
+  // Load existing config when dialog opens
+  const loadConfig = useCallback(async () => {
+    setIsLoading(true)
+    try {
+      const existingConfig = await invoke<SmokeAPIConfig | null>('read_smokeapi_config', {
+        gamePath,
+      })
+
+      if (existingConfig) {
+        setConfig(existingConfig)
+        setEnabled(true)
+      } else {
+        setConfig(DEFAULT_CONFIG)
+        setEnabled(false)
+      }
+      setHasChanges(false)
+    } catch (error) {
+      console.error('Failed to load SmokeAPI config:', error)
+      setConfig(DEFAULT_CONFIG)
+      setEnabled(false)
+    } finally {
+      setIsLoading(false)
+    }
+  }, [gamePath])
+
+  useEffect(() => {
+    if (visible && gamePath) {
+      loadConfig()
+    }
+  }, [visible, gamePath, loadConfig])
+
+  const handleSave = async () => {
+    setIsLoading(true)
+    try {
+      if (enabled) {
+        // Save the config
+        await invoke('write_smokeapi_config', {
+          gamePath,
+          config,
+        })
+      } else {
+        // Delete the config
+        await invoke('delete_smokeapi_config', {
+          gamePath,
+        })
+      }
+      setHasChanges(false)
+      onClose()
+    } catch (error) {
+      console.error('Failed to save SmokeAPI config:', error)
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  const handleCancel = () => {
+    setHasChanges(false)
+    onClose()
+  }
+
+  const updateConfig = <K extends keyof SmokeAPIConfig>(key: K, value: SmokeAPIConfig[K]) => {
+    setConfig((prev) => ({ ...prev, [key]: value }))
+    setHasChanges(true)
+  }
+
+  return (
+    <Dialog visible={visible} onClose={handleCancel} size="medium">
+      <DialogHeader onClose={handleCancel} hideCloseButton={true}>
+        <div className="settings-header">
+          {/*<Icon name={settings} variant="solid" size="md" />*/}
+          <h3>SmokeAPI Settings</h3>
+        </div>
+        <p className="dialog-subtitle">{gameTitle}</p>
+      </DialogHeader>
+
+      <DialogBody>
+        <div className="smokeapi-settings-content">
+          {/* Enable/Disable Section */}
+          <div className="settings-section">
+            <AnimatedCheckbox
+              checked={enabled}
+              onChange={() => {
+                setEnabled(!enabled)
+                setHasChanges(true)
+              }}
+              label="Enable SmokeAPI Configuration"
+              sublabel="Enable this to customize SmokeAPI settings for this game"
+            />
+          </div>
+
+          {/* Settings Options */}
+          <div className={`settings-options ${!enabled ? 'disabled' : ''}`}>
+            <div className="settings-section">
+              <h4>General Settings</h4>
+
+              <Dropdown
+                label="Default App Status"
+                description="Specifies the default DLC status"
+                value={config.default_app_status}
+                options={APP_STATUS_OPTIONS}
+                onChange={(value) => updateConfig('default_app_status', value)}
+                disabled={!enabled}
+              />
+            </div>
+
+            <div className="settings-section">
+              <h4>Logging</h4>
+
+              <div className="checkbox-option">
+                <AnimatedCheckbox
+                  checked={config.logging}
+                  onChange={() => updateConfig('logging', !config.logging)}
+                  label="Enable Logging"
+                  sublabel="Enables logging to SmokeAPI.log.log file"
+                />
+              </div>
+
+              <div className="checkbox-option">
+                <AnimatedCheckbox
+                  checked={config.log_steam_http}
+                  onChange={() => updateConfig('log_steam_http', !config.log_steam_http)}
+                  label="Log Steam HTTP"
+                  sublabel="Toggles logging of SteamHTTP traffic"
+                />
+              </div>
+            </div>
+
+            <div className="settings-section">
+              <h4>Inventory</h4>
+
+              <div className="checkbox-option">
+                <AnimatedCheckbox
+                  checked={config.auto_inject_inventory}
+                  onChange={() =>
+                    updateConfig('auto_inject_inventory', !config.auto_inject_inventory)
+                  }
+                  label="Auto Inject Inventory"
+                  sublabel="Automatically inject a list of all registered inventory items when the game queries user inventory"
+                />
+              </div>
+            </div>
+          </div>
+        </div>
+      </DialogBody>
+
+      <DialogFooter>
+        <DialogActions>
+          <Button variant="secondary" onClick={handleCancel} disabled={isLoading}>
+            Cancel
+          </Button>
+          <Button variant="primary" onClick={handleSave} disabled={isLoading || !hasChanges}>
+            {isLoading ? 'Saving...' : 'Save'}
+          </Button>
+        </DialogActions>
+      </DialogFooter>
+    </Dialog>
+  )
+}
+
+export default SmokeAPISettingsDialog

src/components/dialogs/SmokeAPIVotesDialog.tsx

@@ -0,0 +1,110 @@
+import React, { useEffect, useState } from 'react'
+import { invoke } from '@tauri-apps/api/core'
+import {
+  Dialog,
+  DialogHeader,
+  DialogBody,
+  DialogFooter,
+  DialogActions,
+} from '@/components/dialogs'
+import { Button } from '@/components/buttons'
+import { Icon, info } from '@/components/icons'
+import VotesDisplay, { GameVotes } from '@/components/common/VotesDisplay'
+
+export interface SmokeAPIVotesDialogProps {
+  visible: boolean
+  gameId: string | null
+  gameTitle: string | null
+  onConfirm: () => void
+  onClose: () => void
+}
+
+/**
+ * Shown before installing SmokeAPI on a Proton game.
+ * Fetches and displays community votes for SmokeAPI specifically,
+ * then lets the user confirm or cancel the installation.
+ */
+const SmokeAPIVotesDialog: React.FC<SmokeAPIVotesDialogProps> = ({
+  visible,
+  gameId,
+  gameTitle,
+  onConfirm,
+  onClose,
+}) => {
+  const [votes, setVotes] = useState<GameVotes | null>(null)
+  const [loading, setLoading] = useState(false)
+
+  useEffect(() => {
+    if (!visible || !gameId) {
+      setVotes(null)
+      return
+    }
+
+    setLoading(true)
+    invoke<GameVotes[]>('get_game_votes', { gameId })
+      .then((results) => {
+        setVotes(results.find((v) => v.unlocker === 'smokeapi') ?? null)
+      })
+      .catch(() => setVotes(null))
+      .finally(() => setLoading(false))
+  }, [visible, gameId])
+
+  const hasVotes = votes && (votes.success > 0 || votes.fail > 0)
+
+  return (
+    <Dialog visible={visible} onClose={onClose} size="small">
+      <DialogHeader onClose={onClose} hideCloseButton={true}>
+        <h3>Install SmokeAPI</h3>
+      </DialogHeader>
+
+      <DialogBody>
+        <div className="smokeapi-votes-content">
+          <p className="smokeapi-votes-game">
+            <strong>{gameTitle}</strong>
+          </p>
+
+          <div className="smokeapi-votes-section">
+            <p className="smokeapi-votes-label">Community compatibility</p>
+            {loading ? (
+              <p className="smokeapi-votes-loading">Fetching votes...</p>
+            ) : (
+              <VotesDisplay votes={votes} />
+            )}
+          </div>
+
+          {!loading && !hasVotes && (
+            <div className="smokeapi-votes-notice">
+              <Icon name={info} variant="solid" size="md" />
+              <span>
+                No one has rated this game yet. You'll be able to submit a rating after
+                installing.
+              </span>
+            </div>
+          )}
+
+          {!loading && hasVotes && (
+            <div className="smokeapi-votes-notice">
+              <Icon name={info} variant="solid" size="sm" />
+              <span>
+                These ratings are from other CreamLinux users. Results may vary.
+              </span>
+            </div>
+          )}
+        </div>
+      </DialogBody>
+
+      <DialogFooter>
+        <DialogActions>
+          <Button variant="secondary" onClick={onClose}>
+            Cancel
+          </Button>
+          <Button variant="primary" onClick={onConfirm}>
+            Install anyway
+          </Button>
+        </DialogActions>
+      </DialogFooter>
+    </Dialog>
+  )
+}
+
+export default SmokeAPIVotesDialog

src/components/dialogs/UnlockerSelectionDialog.tsx

@@ -0,0 +1,124 @@
+import React, { useEffect, useState } from 'react'
+import { invoke } from '@tauri-apps/api/core'
+import {
+  Dialog,
+  DialogHeader,
+  DialogBody,
+  DialogFooter,
+  DialogActions,
+} from '@/components/dialogs'
+import { Button } from '@/components/buttons'
+import { Icon, info } from '@/components/icons'
+import VotesDisplay, { GameVotes } from '@/components/common/VotesDisplay'
+
+export interface UnlockerSelectionDialogProps {
+  visible: boolean
+  gameId: string | null
+  gameTitle: string | null
+  onClose: () => void
+  onSelectCreamLinux: () => void
+  onSelectSmokeAPI: () => void
+}
+
+/**
+ * Unlocker Selection Dialog component
+ * Allows users to choose between CreamLinux and SmokeAPI for native Linux games.
+ * Fetches and displays community vote data per unlocker.
+ */
+const UnlockerSelectionDialog: React.FC<UnlockerSelectionDialogProps> = ({
+  visible,
+  gameId,
+  gameTitle,
+  onClose,
+  onSelectCreamLinux,
+  onSelectSmokeAPI,
+}) => {
+  const [creamVotes, setCreamVotes] = useState<GameVotes | null>(null)
+  const [smokeVotes, setSmokeVotes] = useState<GameVotes | null>(null)
+
+  useEffect(() => {
+    if (!visible || !gameId) {
+      setCreamVotes(null)
+      setSmokeVotes(null)
+      return
+    }
+
+    invoke<GameVotes[]>('get_game_votes', { gameId })
+      .then((results) => {
+        setCreamVotes(results.find((v) => v.unlocker === 'creamlinux') ?? null)
+        setSmokeVotes(results.find((v) => v.unlocker === 'smokeapi') ?? null)
+      })
+      .catch(() => {
+        // Votes are non-critical — silently fall back to "No votes yet"
+        setCreamVotes(null)
+        setSmokeVotes(null)
+      })
+  }, [visible, gameId])
+
+  return (
+    <Dialog visible={visible} onClose={onClose} size="medium">
+      <DialogHeader onClose={onClose} hideCloseButton={true}>
+        <div className="unlocker-selection-header">
+          <h3>Choose Unlocker</h3>
+        </div>
+      </DialogHeader>
+
+      <DialogBody>
+        <div className="unlocker-selection-content">
+          <p className="game-title-info">
+            Select which unlocker to install for <strong>{gameTitle}</strong>:
+          </p>
+
+          <div className="unlocker-options">
+            <div className="unlocker-option recommended">
+              <div className="option-header">
+                <h4>CreamLinux</h4>
+                <span className="recommended-badge">Recommended</span>
+              </div>
+              <p className="option-description">
+                Native Linux DLC unlocker. Works best with most native Linux games and provides
+                better compatibility.
+              </p>
+              <VotesDisplay votes={creamVotes} />
+              <Button variant="primary" onClick={onSelectCreamLinux} fullWidth>
+                Install CreamLinux
+              </Button>
+            </div>
+
+            <div className="unlocker-option">
+              <div className="option-header">
+                <h4>SmokeAPI</h4>
+                <span className="alternative-badge">Alternative</span>
+              </div>
+              <p className="option-description">
+                Cross-platform DLC unlocker. Try this if CreamLinux doesn't work for your game.
+                Automatically fetches DLC information.
+              </p>
+              <VotesDisplay votes={smokeVotes} />
+              <Button variant="secondary" onClick={onSelectSmokeAPI} fullWidth>
+                Install SmokeAPI
+              </Button>
+            </div>
+          </div>
+
+          <div className="selection-info">
+            <Icon name={info} variant="solid" size="md" />
+            <span>
+              You can always uninstall and try the other option if one doesn't work properly.
+            </span>
+          </div>
+        </div>
+      </DialogBody>
+
+      <DialogFooter>
+        <DialogActions>
+          <Button variant="secondary" onClick={onClose}>
+            Cancel
+          </Button>
+        </DialogActions>
+      </DialogFooter>
+    </Dialog>
+  )
+}
+
+export default UnlockerSelectionDialog

src/components/dialogs/index.ts

@@ -6,7 +6,15 @@ export { default as DialogFooter } from './DialogFooter'
 export { default as DialogActions } from './DialogActions'
 export { default as ProgressDialog } from './ProgressDialog'
 export { default as DlcSelectionDialog } from './DlcSelectionDialog'
+export { default as AddDlcDialog } from './AddDlcDialog'
 export { default as SettingsDialog } from './SettingsDialog'
+export { default as SmokeAPISettingsDialog } from './SmokeAPISettingsDialog'
+export { default as ConflictDialog } from './ConflictDialog'
+export { default as DisclaimerDialog } from './DisclaimerDialog'
+export { default as UnlockerSelectionDialog } from './UnlockerSelectionDialog'
+export { default as OptInDialog } from './OptInDialog'
+export { default as RatingDialog } from './RatingDialog'
+export { default as SmokeAPIVotesDialog } from './SmokeAPIVotesDialog'
 
 // Export types
 export type { DialogProps } from './Dialog'
@@ -16,3 +24,8 @@ export type { DialogFooterProps } from './DialogFooter'
 export type { DialogActionsProps } from './DialogActions'
 export type { ProgressDialogProps, InstallationInstructions } from './ProgressDialog'
 export type { DlcSelectionDialogProps } from './DlcSelectionDialog'
+export type { AddDlcDialogProps } from './AddDlcDialog'
+export type { ConflictDialogProps, Conflict } from './ConflictDialog'
+export type { UnlockerSelectionDialogProps } from './UnlockerSelectionDialog'
+export type { RatingDialogProps } from './RatingDialog'
+export type { SmokeAPIVotesDialogProps } from './SmokeAPIVotesDialog'

src/components/games/GameItem.tsx

@@ -8,13 +8,16 @@ interface GameItemProps {
   game: Game
   onAction: (gameId: string, action: ActionType) => Promise<void>
   onEdit?: (gameId: string) => void
+  onSmokeAPISettings?: (gameId: string) => void
+  onRate?: (gameId: string) => void
+  reportingEnabled?: boolean // When false/undefined, rate button is not rendered at all.
 }
 
 /**
  * Individual game card component
  * Displays game information and action buttons
  */
-const GameItem = ({ game, onAction, onEdit }: GameItemProps) => {
+const GameItem = ({ game, onAction, onEdit, onSmokeAPISettings, onRate, reportingEnabled }: GameItemProps) => {
   const [imageUrl, setImageUrl] = useState<string | null>(null)
   const [isLoading, setIsLoading] = useState(true)
   const [hasError, setHasError] = useState(false)
@@ -50,11 +53,14 @@ const GameItem = ({ game, onAction, onEdit }: GameItemProps) => {
   }, [game.id, imageUrl])
 
   // Determine if we should show CreamLinux buttons (only for native games)
-  const shouldShowCream = game.native === true
+  const shouldShowCream = game.native && game.cream_installed // Only show if installed (for uninstall)
 
   // Determine if we should show SmokeAPI buttons (only for non-native games with API files)
   const shouldShowSmoke = !game.native && game.api_files && game.api_files.length > 0
 
+  // Show generic button if nothing installed
+  const shouldShowUnlocker = game.native && !game.cream_installed && !game.smoke_installed
+
   // Check if this is a Proton game without API files
   const isProtonNoApi = !game.native && (!game.api_files || game.api_files.length === 0)
 
@@ -70,6 +76,11 @@ const GameItem = ({ game, onAction, onEdit }: GameItemProps) => {
     onAction(game.id, action)
   }
 
+  const handleUnlockerAction = () => {
+    if (game.installing) return
+    onAction(game.id, 'install_unlocker')
+  }
+
   // Handle edit button click
   const handleEdit = () => {
     if (onEdit && game.cream_installed) {
@@ -77,6 +88,20 @@ const GameItem = ({ game, onAction, onEdit }: GameItemProps) => {
     }
   }
 
+  // SmokeAPI settings handler
+  const handleSmokeAPISettings = () => {
+    if (onSmokeAPISettings && game.smoke_installed) {
+      onSmokeAPISettings(game.id)
+    }
+  }
+
+  // Rating handler
+  const handleRate = () => {
+    if (onRate && (game.cream_installed || game.smoke_installed)) {
+      onRate(game.id)
+    }
+  }
+
   // Determine background image
   const backgroundImage =
     !isLoading && imageUrl
@@ -108,17 +133,27 @@ const GameItem = ({ game, onAction, onEdit }: GameItemProps) => {
         </div>
 
         <div className="game-actions">
-          {/* Show CreamLinux button only for native games */}
+          {/* Show generic "Install" button for native games with nothing installed */}
+          {shouldShowUnlocker && (
+            <ActionButton
+              action="install_unlocker"
+              isInstalled={false}
+              isWorking={!!game.installing}
+              onClick={handleUnlockerAction}
+            />
+          )}
+
+          {/* Show CreamLinux uninstall button if CreamLinux is installed */}
           {shouldShowCream && (
             <ActionButton
-              action={game.cream_installed ? 'uninstall_cream' : 'install_cream'}
-              isInstalled={!!game.cream_installed}
+              action="uninstall_cream"
+              isInstalled={true}
               isWorking={!!game.installing}
               onClick={handleCreamAction}
             />
           )}
 
-          {/* Show SmokeAPI button only for Proton/Windows games with API files */}
+          {/* Show SmokeAPI button for Proton games OR native games with SmokeAPI installed */}
           {shouldShowSmoke && (
             <ActionButton
               action={game.smoke_installed ? 'uninstall_smoke' : 'install_smoke'}
@@ -128,6 +163,16 @@ const GameItem = ({ game, onAction, onEdit }: GameItemProps) => {
             />
           )}
 
+          {/* Show SmokeAPI uninstall for native games if installed */}
+          {game.native && game.smoke_installed && (
+            <ActionButton
+              action="uninstall_smoke"
+              isInstalled={true}
+              isWorking={!!game.installing}
+              onClick={handleSmokeAction}
+            />
+          )}
+
           {/* Show message for Proton games without API files */}
           {isProtonNoApi && (
             <div className="api-not-found-message">
@@ -143,6 +188,20 @@ const GameItem = ({ game, onAction, onEdit }: GameItemProps) => {
             </div>
           )}
 
+          {/* Rate button */}
+          {(game.cream_installed || game.smoke_installed) && onRate && reportingEnabled && (
+            <Button
+              variant="primary"
+              size="small"
+              onClick={handleRate}
+              disabled={!!game.installing}
+              title="Rate compatibility"
+              className="edit-button rate-button"
+              leftIcon={<Icon name="Star" variant="solid" size="md" />}
+              iconOnly
+            />
+          )}
+
           {/* Edit button - only enabled if CreamLinux is installed */}
           {game.cream_installed && (
             <Button
@@ -156,6 +215,20 @@ const GameItem = ({ game, onAction, onEdit }: GameItemProps) => {
               iconOnly
             />
           )}
+
+          {/* Edit button - only enabled if SmokeAPI is installed */}
+          {game.smoke_installed && (
+            <Button
+              variant="secondary"
+              size="small"
+              onClick={handleSmokeAPISettings}
+              disabled={!game.smoke_installed || !!game.installing}
+              title="Configure SmokeAPI"
+              className="edit-button settings-icon-button"
+              leftIcon={<Icon name="Settings" variant="solid" size="md" />}
+              iconOnly
+            />
+          )}
         </div>
       </div>
     </div>

src/components/games/GameList.tsx

@@ -9,13 +9,16 @@ interface GameListProps {
   isLoading: boolean
   onAction: (gameId: string, action: ActionType) => Promise<void>
   onEdit?: (gameId: string) => void
+  onSmokeAPISettings?: (gameId: string) => void
+  onRate?: (gameId: string) => void
+  reportingEnabled?: boolean
 }
 
 /**
  * Main game list component
  * Displays games in a grid with search and filtering applied
  */
-const GameList = ({ games, isLoading, onAction, onEdit }: GameListProps) => {
+const GameList = ({ games, isLoading, onAction, onEdit, onSmokeAPISettings, onRate, reportingEnabled }: GameListProps) => {
   const [imagesPreloaded, setImagesPreloaded] = useState(false)
 
   // Sort games alphabetically by title
@@ -56,7 +59,7 @@ const GameList = ({ games, isLoading, onAction, onEdit }: GameListProps) => {
       ) : (
         <div className="game-grid">
           {sortedGames.map((game) => (
-            <GameItem key={game.id} game={game} onAction={onAction} onEdit={onEdit} />
+            <GameItem key={game.id} game={game} onAction={onAction} onEdit={onEdit} onSmokeAPISettings={onSmokeAPISettings} onRate={onRate} reportingEnabled={reportingEnabled} />
           ))}
         </div>
       )}

src/components/icons/index.ts

@@ -29,6 +29,7 @@ export const warning = 'Warning'
 export const wine = 'Wine'
 export const diamond = 'Diamond'
 export const settings = 'Settings'
+export const star = 'Star'
 
 // Brand icons
 export const discord = 'Discord'
@@ -59,6 +60,7 @@ export const IconNames = {
   Wine: wine,
   Diamond: diamond,
   Settings: settings,
+  Star: star,
 
   // Brand icons
   Discord: discord,

src/components/icons/ui/solid/download.svg

@@ -1,4 +1,4 @@
 <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24" color="#000000" fill="none">
-    <path d="M20.25 14.75V10.75C20.25 8.83608 20.2477 7.50125 20.1123 6.49411C19.9808 5.51577 19.7401 4.99789 19.3711 4.62888C19.0021 4.25987 18.4842 4.01921 17.5059 3.88767C16.4987 3.75226 15.1639 3.74997 13.25 3.74997H10.75C8.83611 3.74997 7.50128 3.75226 6.49414 3.88767C5.5158 4.01921 4.99792 4.25987 4.62891 4.62888C4.2599 4.99789 4.01924 5.51577 3.8877 6.49411C3.75229 7.50125 3.75 8.83608 3.75 10.75V14.75C3.75 15.3023 3.30229 15.75 2.75 15.75C2.19772 15.75 1.75 15.3023 1.75 14.75V10.75C1.75 8.89262 1.74779 7.39889 1.90528 6.22751C2.06664 5.02741 2.41231 4.01735 3.21485 3.21481C4.01738 2.41228 5.02745 2.06661 6.22754 1.90524C7.39892 1.74776 8.89265 1.74997 10.75 1.74997H13.25C15.1074 1.74997 16.6011 1.74776 17.7725 1.90524C18.9726 2.06661 19.9826 2.41228 20.7852 3.21481C21.5877 4.01735 21.9334 5.02742 22.0947 6.22751C22.2522 7.39889 22.25 8.89262 22.25 10.75V14.75C22.25 15.3023 21.8023 15.75 21.25 15.75C20.6977 15.75 20.25 15.3023 20.25 14.75Z" fill="currentColor" />
-    <path d="M14.0312 5.74997C15.6419 5.74996 16.9169 5.74997 17.9248 5.86911C18.9557 5.99098 19.8048 6.2463 20.5137 6.82809C20.7541 7.02541 20.9746 7.24589 21.1719 7.4863C21.7537 8.19522 22.009 9.04424 22.1309 10.0752C22.25 11.0831 22.25 12.3581 22.25 13.9687V14.0312C22.25 15.6418 22.25 16.9169 22.1309 17.9248C22.009 18.9557 21.7537 19.8047 21.1719 20.5136C20.9746 20.7541 20.7541 20.9745 20.5137 21.1718C19.8048 21.7536 18.9557 22.009 17.9248 22.1308C16.9169 22.25 15.6419 22.25 14.0312 22.25H9.96875C8.35815 22.25 7.0831 22.25 6.0752 22.1308C5.04427 22.009 4.19525 21.7536 3.48633 21.1718C3.24592 20.9745 3.02544 20.7541 2.82812 20.5136C2.24633 19.8047 1.99101 18.9557 1.86914 17.9248C1.75 16.9169 1.75 15.6418 1.75 14.0312V13.9687C1.75 12.3581 1.75 11.0831 1.86914 10.0752C1.99101 9.04424 2.24633 8.19522 2.82812 7.4863C3.02544 7.24589 3.24592 7.02541 3.48633 6.82809C4.19525 6.2463 5.04427 5.99098 6.0752 5.86911C7.0831 5.74997 8.35815 5.74996 9.96875 5.74997H14.0312ZM12 9.49997C11.4477 9.49997 11 9.94768 11 10.5V15.3906C10.6896 15.0331 10.3585 14.6264 10.1455 14.3535C10.0396 14.2178 9.86489 13.9856 9.80566 13.9072C9.47825 13.4626 8.8519 13.3671 8.40723 13.6943C7.96265 14.0217 7.86716 14.6481 8.19434 15.0927C8.259 15.1784 8.45594 15.4386 8.56934 15.584C8.7953 15.8735 9.10761 16.2629 9.44824 16.6552C9.78455 17.0426 10.1683 17.456 10.5352 17.7802C10.7175 17.9414 10.9198 18.1021 11.1279 18.2275C11.3086 18.3364 11.6228 18.5 12 18.5C12.3772 18.5 12.6914 18.3364 12.8721 18.2275C13.0802 18.1021 13.2825 17.9414 13.4648 17.7802C13.8317 17.4561 14.2154 17.0426 14.5518 16.6552C14.8924 16.2629 15.2047 15.8735 15.4307 15.584C15.5441 15.4386 15.741 15.1784 15.8057 15.0927C16.1328 14.6481 16.0373 14.0227 15.5928 13.6953C15.1481 13.3678 14.5219 13.4635 14.1943 13.9082C14.1351 13.9866 13.9604 14.2178 13.8545 14.3535C13.6415 14.6264 13.3104 15.0331 13 15.3906V10.5C13 9.9477 12.5523 9.49999 12 9.49997Z" fill="currentColor" />
+    <path d="M16.1439 10.8544C15.7604 10.7888 15.2902 10.7658 14.7504 10.7567V4.99991C14.7504 4.5833 14.7563 4.22799 14.6732 3.91788C14.4652 3.1414 13.8589 2.5351 13.0824 2.32706C12.7723 2.24399 12.417 2.24991 12.0004 2.24991C11.5838 2.24991 11.2285 2.244 10.9183 2.32706C10.1419 2.5351 9.53459 3.1414 9.32654 3.91788C9.24355 4.22794 9.25037 4.5834 9.25037 4.99991V10.7567C8.71056 10.7658 8.24038 10.7888 7.85681 10.8544C7.344 10.9421 6.77397 11.1384 6.46033 11.6796L6.40174 11.7929L6.35193 11.9081C6.08178 12.5976 6.3948 13.2355 6.73279 13.7284C7.07715 14.2305 7.6246 14.832 8.28226 15.5546L8.31873 15.5946C9.03427 16.3808 9.62531 17.0262 10.1595 17.4687C10.7074 17.9223 11.2882 18.2426 11.9926 18.2499H12.0082C12.7125 18.2426 13.2934 17.9223 13.8412 17.4687C14.3754 17.0262 14.9665 16.3808 15.682 15.5946L15.7185 15.5546C16.3761 14.832 16.9236 14.2305 17.2679 13.7284C17.6059 13.2355 17.919 12.5976 17.6488 11.9081L17.599 11.7929L17.5404 11.6796C17.2268 11.1384 16.6567 10.9421 16.1439 10.8544Z" fill="currentColor" />
+    <path d="M18.75 19.7499C19.3023 19.7499 19.75 20.1976 19.75 20.7499C19.75 21.3022 19.3023 21.7499 18.75 21.7499H5.25C4.69772 21.7499 4.25 21.3022 4.25 20.7499C4.25 20.1976 4.69772 19.7499 5.25 19.7499H18.75Z" fill="currentColor" />
 </svg>

src/components/icons/ui/solid/index.ts

@@ -13,6 +13,7 @@ export { ReactComponent as Layers } from './layers.svg'
 export { ReactComponent as Refresh } from './refresh.svg'
 export { ReactComponent as Search } from './search.svg'
 export { ReactComponent as Settings } from './settings.svg'
+export { ReactComponent as Star } from './star.svg'
 export { ReactComponent as Trash } from './trash.svg'
 export { ReactComponent as Warning } from './warning.svg'
 export { ReactComponent as Wine } from './wine.svg'

src/components/icons/ui/solid/star.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24" color="currentColor" fill="none">
+    <path d="M11.9961 1.25C13.0454 1.25 13.8719 2.04253 14.3995 3.11191L16.1616 6.66516C16.215 6.77513 16.3417 6.92998 16.5321 7.07164C16.7223 7.21315 16.9086 7.29121 17.0311 7.3118L20.2207 7.84613C21.3729 8.03973 22.3386 8.60449 22.6521 9.5879C22.9653 10.5705 22.5064 11.5916 21.6778 12.4216L21.677 12.4225L19.1991 14.9209C19.1009 15.0199 18.9909 15.2064 18.9219 15.4494C18.8534 15.6908 18.8473 15.9107 18.8784 16.0527L18.8788 16.0547L19.5877 19.1454C19.8818 20.4317 19.7843 21.7073 18.8771 22.3742C17.9667 23.0433 16.7227 22.7467 15.5925 22.0736L12.6026 20.289C12.477 20.214 12.2614 20.1532 12.0011 20.1532C11.7427 20.1532 11.5226 20.2132 11.3888 20.291L11.3869 20.2921L8.40288 22.0732C7.27405 22.7487 6.03154 23.04 5.12111 22.3702C4.21449 21.7032 4.11214 20.43 4.40711 19.1447L5.1159 16.0547L5.11633 16.0527C5.14741 15.9107 5.14133 15.6908 5.0728 15.4494C5.0038 15.2064 4.89379 15.0199 4.79558 14.9209L2.31585 12.4206C1.49265 11.5906 1.03521 10.5704 1.34595 9.58925C1.65759 8.60525 2.62143 8.0398 3.77433 7.84606L6.96132 7.31219L6.96233 7.31202C7.07917 7.29175 7.2627 7.21456 7.45248 7.07268C7.64261 6.93054 7.76959 6.77535 7.82312 6.66516L7.82582 6.65967L9.58562 3.11097L9.58632 3.10957C10.119 2.04108 10.948 1.25 11.9961 1.25Z" fill="currentColor" />
+</svg>

src/components/icons/ui/stroke/download.svg

@@ -1,5 +1,4 @@
 <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24" color="#000000" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
-    <path d="M14 21.5H10C6.71252 21.5 5.06878 21.5 3.96243 20.592C3.75989 20.4258 3.57418 20.2401 3.40796 20.0376C2.5 18.9312 2.5 17.2875 2.5 14C2.5 10.7125 2.5 9.06878 3.40796 7.96243C3.57418 7.75989 3.75989 7.57418 3.96243 7.40796C5.06878 6.5 6.71252 6.5 10 6.5H14C17.2875 6.5 18.9312 6.5 20.0376 7.40796C20.2401 7.57418 20.4258 7.75989 20.592 7.96243C21.5 9.06878 21.5 10.7125 21.5 14C21.5 17.2875 21.5 18.9312 20.592 20.0376C20.4258 20.2401 20.2401 20.4258 20.0376 20.592C18.9312 21.5 17.2875 21.5 14 21.5Z" />
-    <path d="M2.5 14.5V10.5C2.5 6.72876 2.5 4.84315 3.67157 3.67157C4.84315 2.5 6.72876 2.5 10.5 2.5H13.5C17.2712 2.5 19.1569 2.5 20.3284 3.67157C21.5 4.84315 21.5 6.72876 21.5 10.5V14.5" />
-    <path d="M15 14.5C15 14.5 12.7905 17.4999 12 17.4999C11.2094 17.5 9 14.4999 9 14.4999M12 17L12 10.5" />
+    <path d="M16.9504 12.1817C17.1981 12.814 16.5076 13.5726 15.1267 15.0899C13.6702 16.6902 12.9201 17.4904 12 17.5C11.0799 17.4904 10.3298 16.6902 8.87331 15.0899C7.49239 13.5726 6.80193 12.814 7.04964 12.1817C7.05868 12.1586 7.06851 12.1359 7.0791 12.1135C7.34928 11.542 8.24477 11.5029 10 11.5002V4.99998C10 4.53501 10 4.30253 10.0511 4.11179C10.1898 3.59414 10.5941 3.1898 11.1118 3.05111C11.3025 3 11.535 3 12 3C12.4649 3 12.6974 3 12.8882 3.05111C13.4058 3.1898 13.8102 3.59414 13.9489 4.11179C14 4.30253 14 4.53501 14 4.99998V11.5002C15.7552 11.5029 16.6507 11.542 16.9209 12.1135C16.9315 12.1359 16.9413 12.1586 16.9504 12.1817Z" />
+    <path d="M5.00006 21H19.0001" />
 </svg>

src/components/icons/ui/stroke/index.ts

@@ -13,6 +13,7 @@ export { ReactComponent as Layers } from './layers.svg'
 export { ReactComponent as Refresh } from './refresh.svg'
 export { ReactComponent as Search } from './search.svg'
 export { ReactComponent as Settings } from './settings.svg'
+export { ReactComponent as Star } from './star.svg'
 export { ReactComponent as Trash } from './trash.svg'
 export { ReactComponent as Warning } from './warning.svg'
 export { ReactComponent as Wine } from './wine.svg'

src/components/icons/ui/stroke/star.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24" color="currentColor" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M13.7276 3.44418L15.4874 6.99288C15.7274 7.48687 16.3673 7.9607 16.9073 8.05143L20.0969 8.58575C22.1367 8.92853 22.6167 10.4206 21.1468 11.8925L18.6671 14.3927C18.2471 14.8161 18.0172 15.6327 18.1471 16.2175L18.8571 19.3125C19.417 21.7623 18.1271 22.71 15.9774 21.4296L12.9877 19.6452C12.4478 19.3226 11.5579 19.3226 11.0079 19.6452L8.01827 21.4296C5.8785 22.71 4.57865 21.7522 5.13859 19.3125L5.84851 16.2175C5.97849 15.6327 5.74852 14.8161 5.32856 14.3927L2.84884 11.8925C1.389 10.4206 1.85895 8.92853 3.89872 8.58575L7.08837 8.05143C7.61831 7.9607 8.25824 7.48687 8.49821 6.99288L10.258 3.44418C11.2179 1.51861 12.7777 1.51861 13.7276 3.44418Z" />
+</svg>

src/contexts/AppContext.tsx

@@ -1,6 +1,7 @@
 import { createContext } from 'react'
 import { Game, DlcInfo } from '@/types'
 import { ActionType } from '@/components/buttons/ActionButton'
+import { DlcDialogState } from '@/hooks/useDlcManager'
 
 // Types for context sub-components
 export interface InstallationInstructions {
@@ -10,17 +11,6 @@ export interface InstallationInstructions {
   dlc_count?: number
 }
 
-export interface DlcDialogState {
-  visible: boolean
-  gameId: string
-  gameTitle: string
-  dlcs: DlcInfo[]
-  isLoading: boolean
-  isEditMode: boolean
-  progress: number
-  timeLeft?: string
-}
-
 export interface ProgressDialogState {
   visible: boolean
   title: string
@@ -30,6 +20,20 @@ export interface ProgressDialogState {
   instructions?: InstallationInstructions
 }
 
+export interface SmokeAPISettingsDialogState {
+  visible: boolean
+  gamePath: string
+  gameTitle: string
+}
+
+export interface RatingDialogState {
+  visible: boolean
+  gameId: string
+  gameTitle: string
+  unlocker: 'creamlinux' | 'smokeapi'
+  steamPath: string
+}
+
 // Define the context type
 export interface AppContextType {
   // Game state
@@ -43,6 +47,7 @@ export interface AppContextType {
   dlcDialog: DlcDialogState
   handleGameEdit: (gameId: string) => void
   handleDlcDialogClose: () => void
+  handleUpdateDlcs: (gameId: string) => Promise<void>
 
   // Game actions
   progressDialog: ProgressDialogState
@@ -54,13 +59,44 @@ export interface AppContextType {
   handleSettingsOpen: () => void
   handleSettingsClose: () => void
 
+  // SmokeAPI settings
+  smokeAPISettingsDialog: SmokeAPISettingsDialogState
+  handleSmokeAPISettingsOpen: (gameId: string) => void
+  handleSmokeAPISettingsClose: () => void
+
+  // SmokeAPI votes dialog
+  smokeAPIVotesDialog: {
+  visible: boolean
+  gameId: string | null
+  gameTitle: string | null
+  }
+  handleSmokeAPIVotesClose: () => void
+  handleSmokeAPIVotesConfirm: () => void
+
+  // Rating dialog
+  ratingDialog: RatingDialogState
+  handleOpenRating: (gameId: string) => void
+  handleCloseRating: () => void
+  handleSubmitRating: (worked: boolean) => Promise<void>
+  reportingEnabled: boolean
+
   // Toast notifications
   showToast: (
     message: string,
     type: 'success' | 'error' | 'warning' | 'info',
     options?: Record<string, unknown>
   ) => void
+
+  // Unlocker selection
+  unlockerSelectionDialog: {
+    visible: boolean
+    gameId: string | null
+    gameTitle: string | null
+  }
+  handleSelectCreamLinux: () => void
+  handleSelectSmokeAPI: () => void
+  closeUnlockerDialog: () => void
 }
 
 // Create the context with a default value
-export const AppContext = createContext<AppContextType | undefined>(undefined)
+export const AppContext = createContext<AppContextType | undefined>(undefined)

src/contexts/AppProvider.tsx

@@ -1,9 +1,11 @@
-import { ReactNode, useState } from 'react'
+import { ReactNode, useState, useEffect } from 'react'
 import { AppContext, AppContextType } from './AppContext'
 import { useGames, useDlcManager, useGameActions, useToasts } from '@/hooks'
-import { DlcInfo } from '@/types'
+import { DlcInfo, Config } from '@/types'
 import { ActionType } from '@/components/buttons/ActionButton'
 import { ToastContainer } from '@/components/notifications'
+import { SmokeAPISettingsDialog, OptInDialog, RatingDialog, SmokeAPIVotesDialog } from '@/components/dialogs'
+import { invoke } from '@tauri-apps/api/core'
 
 // Context provider component
 interface AppProviderProps {
@@ -24,6 +26,7 @@ export const AppProvider = ({ children }: AppProviderProps) => {
     handleDlcDialogClose: closeDlcDialog,
     streamGameDlcs,
     handleGameEdit,
+    handleUpdateDlcs,
   } = useDlcManager()
 
   const {
@@ -31,6 +34,8 @@ export const AppProvider = ({ children }: AppProviderProps) => {
     handleCloseProgressDialog,
     handleGameAction: executeGameAction,
     handleDlcConfirm: executeDlcConfirm,
+    unlockerSelectionDialog,
+    closeUnlockerDialog,
   } = useGameActions()
 
   const { toasts, removeToast, success, error: showError, warning, info } = useToasts()
@@ -38,6 +43,58 @@ export const AppProvider = ({ children }: AppProviderProps) => {
   // Settings dialog state
   const [settingsDialog, setSettingsDialog] = useState({ visible: false })
 
+  // SmokeAPI settings dialog state
+  const [smokeAPISettingsDialog, setSmokeAPISettingsDialog] = useState<{
+    visible: boolean
+    gamePath: string
+    gameTitle: string
+  }>({
+    visible: false,
+    gamePath: '',
+    gameTitle: '',
+  })
+
+  // SmokeAPI votes dialog state
+  const [smokeAPIVotesDialog, setSmokeAPIVotesDialog] = useState<{
+    visible: boolean
+    gameId: string | null
+    gameTitle: string | null
+  }>({
+    visible: false,
+    gameId: null,
+    gameTitle: null,
+  })
+
+  // Opt-in dialog state
+  const [optInDialog, setOptInDialog] = useState(false)
+  const [reportingEnabled, setReportingEnabled] = useState(false)
+
+  // Rating dialog state
+  const [ratingDialog, setRatingDialog] = useState<{
+    visible: boolean
+    gameId: string
+    gameTitle: string
+    unlocker: 'creamlinux' | 'smokeapi'
+    steamPath: string
+  }>({
+    visible: false,
+    gameId: '',
+    gameTitle: '',
+    unlocker: 'creamlinux',
+    steamPath: '',
+  })
+
+  useEffect(() => {
+    invoke<Config>('load_config')
+      .then((cfg) => {
+        setReportingEnabled(cfg.reporting_opted_in)
+        if (!cfg.reporting_has_seen_prompt) {
+          setOptInDialog(true)
+        }
+      })
+      .catch((err) => console.error('Failed to load config for reporting check:', err))
+  }, [])
+
   // Settings handlers
   const handleSettingsOpen = () => {
     setSettingsDialog({ visible: true })
@@ -47,6 +104,92 @@ export const AppProvider = ({ children }: AppProviderProps) => {
     setSettingsDialog({ visible: false })
   }
 
+  // SmokeAPI settings handlers
+  const handleSmokeAPISettingsOpen = (gameId: string) => {
+    const game = games.find((g) => g.id === gameId)
+    if (!game) {
+      showError('Game not found')
+      return
+    }
+
+    setSmokeAPISettingsDialog({
+      visible: true,
+      gamePath: game.path,
+      gameTitle: game.title,
+    })
+  }
+
+  const handleSmokeAPISettingsClose = () => {
+    setSmokeAPISettingsDialog({
+      visible: false,
+      gamePath: '',
+      gameTitle: '',
+    })
+  }
+
+  const handleSmokeAPIVotesClose = () => {
+    setSmokeAPIVotesDialog({ visible: false, gameId: null, gameTitle: null })
+  }
+
+  const handleSmokeAPIVotesConfirm = () => {
+    const gameId = smokeAPIVotesDialog.gameId
+    setSmokeAPIVotesDialog({ visible: false, gameId: null, gameTitle: null })
+    if (gameId) {
+      // Now actually run the install
+      executeGameAction(gameId, 'install_smoke', games)
+    }
+  }
+
+  const handleOptInAccept = async () => {
+    try {
+      await invoke('set_reporting_opt_in', { optedIn: true })
+      setReportingEnabled(true)
+    } catch (err) {
+      console.error('Failed to save reporting opt-in:', err)
+    }
+    setOptInDialog(false)
+  }
+
+  const handleOptInDecline = async () => {
+    try {
+      await invoke('set_reporting_opt_in', { optedIn: false })
+      setReportingEnabled(false)
+    } catch (err) {
+      console.error('Failed to save reporting opt-out:', err)
+    }
+    setOptInDialog(false)
+  }
+
+  const handleOpenRating = (gameId: string) => {
+    const game = games.find((g) => g.id === gameId)
+    if (!game) return
+
+    setRatingDialog({
+      visible: true,
+      gameId,
+      gameTitle: game.title,
+      unlocker: game.cream_installed ? 'creamlinux' : 'smokeapi',
+      steamPath: game.path,
+    })
+  }
+
+  const handleCloseRating = () => {
+    setRatingDialog((prev) => ({ ...prev, visible: false }))
+  }
+
+  const handleSubmitRating = async (worked: boolean) => {
+    try {
+      await invoke('submit_report', {
+        gameId: ratingDialog.gameId,
+        unlocker: ratingDialog.unlocker,
+        worked,
+        steamPath: ratingDialog.steamPath,
+      })
+    } catch (err) {
+      console.error('Failed to submit rating:', err)
+    }
+  }
+
   // Game action handler with proper error reporting
   const handleGameAction = async (gameId: string, action: ActionType) => {
     const game = games.find((g) => g.id === gameId)
@@ -79,6 +222,38 @@ export const AppProvider = ({ children }: AppProviderProps) => {
       }
     }
 
+    // intercept install_smoke for votes dialog
+    if (action === 'install_smoke' && !game.native) {
+      setSmokeAPIVotesDialog({
+        visible: true,
+        gameId: game.id,
+        gameTitle: game.title,
+      })
+      return
+    }
+
+    // For install_unlocker action, executeGameAction will handle showing the dialog
+    // We should NOT show any notifications here - they'll be shown after actual installation
+    if (action === 'install_unlocker') {
+      // Mark game as installing while the user makes a selection
+      setGames((prevGames) =>
+        prevGames.map((g) => (g.id === gameId ? { ...g, installing: true } : g))
+      )
+
+      try {
+        // This will show the UnlockerSelectionDialog and handle the callback
+        await executeGameAction(gameId, action, games)
+      } catch (error) {
+        showError(`Action failed: ${error}`)
+      } finally {
+        // Reset installing state
+        setGames((prevGames) =>
+          prevGames.map((g) => (g.id === gameId ? { ...g, installing: false } : g))
+        )
+      }
+      return // Don't show any notifications for install_unlocker
+    }
+
     // For other actions (uninstall cream, install/uninstall smoke)
     // Mark game as installing
     setGames((prevGames) =>
@@ -89,7 +264,7 @@ export const AppProvider = ({ children }: AppProviderProps) => {
       await executeGameAction(gameId, action, games)
 
       // Show appropriate success message based on action type
-      const product = action.includes('cream') ? 'Creamlinux' : 'SmokeAPI'
+      const product = action.includes('cream') ? 'CreamLinux' : 'SmokeAPI'
       const isUninstall = action.includes('uninstall')
       const isInstall = action.includes('install') && !isUninstall
 
@@ -189,6 +364,7 @@ export const AppProvider = ({ children }: AppProviderProps) => {
       handleGameEdit(gameId, games)
     },
     handleDlcDialogClose: closeDlcDialog,
+    handleUpdateDlcs: (gameId: string) => handleUpdateDlcs(gameId),
 
     // Game actions
     progressDialog,
@@ -201,14 +377,112 @@ export const AppProvider = ({ children }: AppProviderProps) => {
     handleSettingsOpen,
     handleSettingsClose,
 
+    // SmokeAPI Settings
+    smokeAPISettingsDialog,
+    handleSmokeAPISettingsOpen,
+    handleSmokeAPISettingsClose,
+
+    // SmokeAPI Votes
+    smokeAPIVotesDialog,
+    handleSmokeAPIVotesClose,
+    handleSmokeAPIVotesConfirm,
+
+    // Rating
+    ratingDialog,
+    handleOpenRating,
+    handleCloseRating,
+    handleSubmitRating,
+    reportingEnabled,
+
     // Toast notifications
     showToast,
+
+    // Unlocker selection - Pass wrapped handlers that also handle the installing state
+    unlockerSelectionDialog,
+    handleSelectCreamLinux: () => {
+      // When CreamLinux is selected, trigger the DLC dialog flow
+      const gameId = unlockerSelectionDialog.gameId
+      if (gameId) {
+        const game = games.find((g) => g.id === gameId)
+        if (game) {
+
+          closeUnlockerDialog()
+
+          // Reset installing state before showing DLC dialog
+          setGames((prevGames) =>
+            prevGames.map((g) => (g.id === gameId ? { ...g, installing: false } : g))
+          )
+          // Show DLC selection dialog directly
+          setDlcDialog({
+            ...dlcDialog,
+            visible: true,
+            gameId,
+            gameTitle: game.title,
+            dlcs: [],
+            isLoading: true,
+            isEditMode: false,
+            progress: 0,
+          })
+
+          streamGameDlcs(gameId)
+        }
+      }
+    },
+    handleSelectSmokeAPI: () => {
+      // When SmokeAPI is selected, trigger the actual installation
+      const gameId = unlockerSelectionDialog.gameId
+      if (gameId) {
+        const game = games.find((g) => g.id === gameId)
+        if (game) {
+          closeUnlockerDialog()
+
+          setTimeout(() => {
+            handleGameAction(gameId, 'install_smoke')
+          }, 0)
+        }
+      }
+    },
+    closeUnlockerDialog,
   }
 
   return (
     <AppContext.Provider value={contextValue}>
       {children}
       <ToastContainer toasts={toasts} onDismiss={removeToast} />
+      
+      {/* SmokeAPI Settings Dialog */}
+      <SmokeAPISettingsDialog
+        visible={smokeAPISettingsDialog.visible}
+        onClose={handleSmokeAPISettingsClose}
+        gamePath={smokeAPISettingsDialog.gamePath}
+        gameTitle={smokeAPISettingsDialog.gameTitle}
+      />
+
+      {/* SmokeAPI Votes Dialog */}
+      <SmokeAPIVotesDialog
+        visible={smokeAPIVotesDialog.visible}
+        gameId={smokeAPIVotesDialog.gameId}
+        gameTitle={smokeAPIVotesDialog.gameTitle}
+        onClose={handleSmokeAPIVotesClose}
+        onConfirm={handleSmokeAPIVotesConfirm}
+      />
+
+      {/* Opt-in Dialog */}
+      <OptInDialog
+        visible={optInDialog}
+        onAccept={handleOptInAccept}
+        onDecline={handleOptInDecline}
+      />
+
+      {/* Rating Dialog */}
+      <RatingDialog
+        visible={ratingDialog.visible}
+        gameId={ratingDialog.gameId}
+        gameTitle={ratingDialog.gameTitle}
+        unlocker={ratingDialog.unlocker}
+        onClose={handleCloseRating}
+        onSubmit={handleSubmitRating}
+      />
     </AppContext.Provider>
   )
-}
+}

src/hooks/index.ts

@@ -4,7 +4,11 @@ export { useDlcManager } from './useDlcManager'
 export { useGameActions } from './useGameActions'
 export { useToasts } from './useToasts'
 export { useAppLogic } from './useAppLogic'
+export { useConflictDetection } from './useConflictDetection'
+export { useDisclaimer } from './useDisclaimer'
+export { useUnlockerSelection } from './useUnlockerSelection'
 
 // Export types
 export type { ToastType, Toast, ToastOptions } from './useToasts'
 export type { DlcDialogState } from './useDlcManager'
+export type { Conflict, ConflictResolution } from './useConflictDetection'

src/hooks/useConflictDetection.ts

@@ -0,0 +1,102 @@
+import { useState, useEffect, useCallback } from 'react'
+import { Game } from '@/types'
+
+export interface Conflict {
+  gameId: string
+  gameTitle: string
+  type: 'cream-to-proton' | 'smoke-to-native'
+}
+
+export interface ConflictResolution {
+  gameId: string
+  conflictType: 'cream-to-proton' | 'smoke-to-native'
+}
+
+/**
+ * Hook for detecting platform conflicts
+ * Identifies when unlocker files exist for the wrong platform
+ */
+export function useConflictDetection(games: Game[]) {
+  const [conflicts, setConflicts] = useState<Conflict[]>([])
+  const [showDialog, setShowDialog] = useState(false)
+  const [resolvedConflicts, setResolvedConflicts] = useState<Set<string>>(new Set())
+  const [hasShownThisSession, setHasShownThisSession] = useState(false)
+
+  // Detect conflicts whenever games change
+  useEffect(() => {
+    const detectedConflicts: Conflict[] = []
+
+    games.forEach((game) => {
+      // Skip if we've already resolved a conflict for this game
+      if (resolvedConflicts.has(game.id)) {
+        return
+      }
+
+      // Conflict 1: CreamLinux installed but game is now Proton
+      if (!game.native && game.cream_installed) {
+        detectedConflicts.push({
+          gameId: game.id,
+          gameTitle: game.title,
+          type: 'cream-to-proton',
+        })
+      }
+
+      // Conflict 2: Orphaned Proton SmokeAPI DLL files on a native game
+      if (game.native && game.smoke_installed && game.api_files && game.api_files.length > 0) {
+        detectedConflicts.push({
+          gameId: game.id,
+          gameTitle: game.title,
+          type: 'smoke-to-native',
+        })
+      }
+    })
+
+    setConflicts(detectedConflicts)
+
+    // Show dialog only if:
+    // 1. We have conflicts
+    // 2. Dialog isn't already visible
+    // 3. We haven't shown it this session
+    if (detectedConflicts.length > 0 && !showDialog && !hasShownThisSession) {
+      setShowDialog(true)
+      setHasShownThisSession(true)
+    }
+  }, [games, resolvedConflicts, showDialog, hasShownThisSession])
+
+  // Handle resolving a single conflict
+  const resolveConflict = useCallback(
+    (gameId: string, conflictType: 'cream-to-proton' | 'smoke-to-native'): ConflictResolution => {
+      // Mark this game as resolved
+      setResolvedConflicts((prev) => new Set(prev).add(gameId))
+
+      // Remove from conflicts list
+      setConflicts((prev) => prev.filter((c) => c.gameId !== gameId))
+
+      return {
+        gameId,
+        conflictType,
+      }
+    },
+    []
+  )
+
+  // Auto-close dialog when all conflicts are resolved
+  useEffect(() => {
+    if (conflicts.length === 0 && showDialog) {
+      setShowDialog(false)
+    }
+  }, [conflicts.length, showDialog])
+
+  // Handle dialog close
+  const closeDialog = useCallback(() => {
+    setShowDialog(false)
+  }, [])
+
+  return {
+    conflicts,
+    showDialog,
+    resolveConflict,
+    closeDialog,
+    hasConflicts: conflicts.length > 0,
+  }
+}

src/hooks/useDisclaimer.ts

@@ -0,0 +1,58 @@
+import { useState, useEffect } from 'react'
+import { invoke } from '@tauri-apps/api/core'
+import { Config } from '@/types/Config'
+
+/**
+ * Hook to manage disclaimer dialog state
+ * Loads config on mount and provides methods to update it
+ */
+export function useDisclaimer() {
+  const [showDisclaimer, setShowDisclaimer] = useState(false)
+  const [isLoading, setIsLoading] = useState(true)
+
+  // Load config on mount
+  useEffect(() => {
+    loadConfig()
+  }, [])
+
+  const loadConfig = async () => {
+    try {
+      const config = await invoke<Config>('load_config')
+      setShowDisclaimer(config.show_disclaimer)
+    } catch (error) {
+      console.error('Failed to load config:', error)
+      // Default to showing disclaimer if config load fails
+      setShowDisclaimer(true)
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  const handleDisclaimerClose = async (dontShowAgain: boolean) => {
+    setShowDisclaimer(false)
+
+    if (dontShowAgain) {
+      try {
+        // Load the current config first
+        const currentConfig = await invoke<Config>('load_config')
+
+        // Update the show_disclaimer field
+        const updatedConfig: Config = {
+          ...currentConfig,
+          show_disclaimer: false,
+        }
+
+        // Save the updated config
+        await invoke('update_config', { configData: updatedConfig })
+      } catch (error) {
+        console.error('Failed to update config:', error)
+      }
+    }
+  }
+
+  return {
+    showDisclaimer,
+    isLoading,
+    handleDisclaimerClose,
+  }
+}

src/hooks/useDlcManager.ts

@@ -11,10 +11,13 @@ export interface DlcDialogState {
   enabledDlcs: string[]
   isLoading: boolean
   isEditMode: boolean
+  isUpdating: boolean
+  updateAttempted: boolean
   progress: number
   progressMessage: string
   timeLeft: string
   error: string | null
+  newDlcsCount: number
 }
 
 /**
@@ -36,10 +39,13 @@ export function useDlcManager() {
     enabledDlcs: [],
     isLoading: false,
     isEditMode: false,
+    isUpdating: false,
+    updateAttempted: false,
     progress: 0,
     progressMessage: '',
     timeLeft: '',
     error: null,
+    newDlcsCount: 0,
   })
 
   // Set up event listeners for DLC streaming
@@ -80,6 +86,7 @@ export function useDlcManager() {
               setDlcDialog((prev) => ({
                 ...prev,
                 isLoading: false,
+                isUpdating: false,
               }))
 
               // Reset fetch state
@@ -177,10 +184,13 @@ export function useDlcManager() {
         enabledDlcs: [],
         isLoading: true,
         isEditMode: true,
+        isUpdating: false,
+        updateAttempted: false,
         progress: 0,
         progressMessage: 'Reading DLC configuration...',
         timeLeft: '',
         error: null,
+        newDlcsCount: 0,
       })
 
       // Always get a fresh copy from the config file
@@ -302,6 +312,58 @@ export function useDlcManager() {
     }
   }, [dlcDialog.dlcs, dlcDialog.enabledDlcs])
 
+  // Function to update DLC list (refetch from Steam API)
+  const handleUpdateDlcs = async (gameId: string) => {
+    try {
+      // Store current app IDs to identify new DLCs later
+      const currentAppIds = new Set(dlcDialog.dlcs.map((dlc) => dlc.appid))
+
+      // Set updating state and clear DLCs
+      setDlcDialog((prev) => ({
+        ...prev,
+        isUpdating: true,
+        isLoading: true,
+        updateAttempted: true,
+        progress: 0,
+        progressMessage: 'Checking for new DLCs...',
+        newDlcsCount: 0,
+        dlcs: [], // Clear current DLCs to start fresh
+      }))
+
+      // Mark that we're fetching DLCs for this game
+      setIsFetchingDlcs(true)
+      activeDlcFetchId.current = gameId
+
+      // Start streaming DLCs
+      await streamGameDlcs(gameId)
+      
+      // After streaming completes, calculate new DLCs
+      // Wait a bit longer to ensure all DLCs have been added
+      setTimeout(() => {
+        setDlcDialog((prev) => {
+          // Count how many DLCs are new (not in the original list)
+          const actualNewCount = prev.dlcs.filter(dlc => !currentAppIds.has(dlc.appid)).length
+          
+          console.log(`Update complete: Found ${actualNewCount} new DLCs out of ${prev.dlcs.length} total`)
+          
+          return {
+            ...prev,
+            newDlcsCount: actualNewCount,
+          }
+        })
+      }, 1500) // Increased timeout to ensure all DLCs are processed
+      
+    } catch (error) {
+      console.error('Error updating DLCs:', error)
+      setDlcDialog((prev) => ({
+        ...prev,
+        error: `Failed to update DLCs: ${error}`,
+        isLoading: false,
+        isUpdating: false,
+      }))
+    }
+  }
+
   return {
     dlcDialog,
     setDlcDialog,
@@ -309,6 +371,7 @@ export function useDlcManager() {
     streamGameDlcs,
     handleGameEdit,
     handleDlcDialogClose,
+    handleUpdateDlcs,
     forceReload,
   }
-}
+}

src/hooks/useGameActions.ts

@@ -4,6 +4,7 @@ import { listen } from '@tauri-apps/api/event'
 import { ActionType } from '@/components/buttons/ActionButton'
 import { Game, DlcInfo } from '@/types'
 import { InstallationInstructions } from '@/contexts/AppContext'
+import { useUnlockerSelection } from './useUnlockerSelection'
 
 /**
  * Hook for managing game action operations
@@ -79,22 +80,38 @@ export function useGameActions() {
     setProgressDialog((prev) => ({ ...prev, visible: false }))
   }, [])
 
+  // Unlocker selection hook for native games
+  const {
+    selectionState,
+    showUnlockerSelection,
+    handleSelectCreamLinux,
+    handleSelectSmokeAPI,
+    closeDialog: closeUnlockerDialog,
+  } = useUnlockerSelection()
+
   // Unified handler for game actions (install/uninstall)
   const handleGameAction = useCallback(
     async (gameId: string, action: ActionType, games: Game[]) => {
       try {
-        // For CreamLinux installation, we should NOT call process_game_action directly
-        // Instead, we show the DLC selection dialog first, which is handled in AppProvider
+        // Find the game
+        const game = games.find((g) => g.id === gameId)
+        if (!game) return
+
+        // For CreamLinux installation, DLC dialog is handled in AppProvider
         if (action === 'install_cream') {
           return
         }
 
-        // For other actions (uninstall_cream, install_smoke, uninstall_smoke)
-        // Find game to get title
-        const game = games.find((g) => g.id === gameId)
-        if (!game) return
+        // Handle generic "install_unlocker" action for native games
+        if (action === 'install_unlocker') {
+          showUnlockerSelection(game, (chosenAction: ActionType) => {
+            // User chose, now proceed with that action
+            handleGameAction(gameId, chosenAction, games)
+          })
+          return
+        }
 
-        // Get title based on action
+        // For other actions (uninstall_cream, install_smoke, uninstall_smoke)
         const isCream = action.includes('cream')
         const isInstall = action.includes('install')
         const product = isCream ? 'CreamLinux' : 'SmokeAPI'
@@ -138,7 +155,7 @@ export function useGameActions() {
         throw error
       }
     },
-    []
+    [showUnlockerSelection]
   )
 
   // Handle DLC selection confirmation
@@ -231,5 +248,9 @@ export function useGameActions() {
     handleCloseProgressDialog,
     handleGameAction,
     handleDlcConfirm,
+    unlockerSelectionDialog: selectionState,
+    handleSelectCreamLinux,
+    handleSelectSmokeAPI,
+    closeUnlockerDialog,
   }
 }

src/hooks/useUnlockerSelection.ts

@@ -0,0 +1,71 @@
+import { useState, useCallback } from 'react'
+import { Game } from '@/types'
+import { ActionType } from '@/components/buttons'
+
+export interface UnlockerSelectionState {
+  visible: boolean
+  gameId: string | null
+  gameTitle: string | null
+}
+
+/**
+ * Hook for managing unlocker selection on native games
+ */
+export function useUnlockerSelection() {
+  const [selectionState, setSelectionState] = useState<UnlockerSelectionState>({
+    visible: false,
+    gameId: null,
+    gameTitle: null,
+  })
+
+  // Store the callback to call when user makes a selection
+  const [selectionCallback, setSelectionCallback] = useState<((action: ActionType) => void) | null>(
+    null
+  )
+
+  // Show the dialog and store the callback
+  const showUnlockerSelection = useCallback(
+    (game: Game, callback: (action: ActionType) => void) => {
+      setSelectionState({
+        visible: true,
+        gameId: game.id,
+        gameTitle: game.title,
+      })
+      // Wrap in function to avoid stale closure
+      setSelectionCallback(() => callback)
+    },
+    []
+  )
+
+  // User selected CreamLinux
+  const handleSelectCreamLinux = useCallback(() => {
+    setSelectionState({ visible: false, gameId: null, gameTitle: null })
+    if (selectionCallback) {
+      selectionCallback('install_cream')
+    }
+    setSelectionCallback(null)
+  }, [selectionCallback])
+
+  // User selected SmokeAPI
+  const handleSelectSmokeAPI = useCallback(() => {
+    setSelectionState({ visible: false, gameId: null, gameTitle: null })
+    if (selectionCallback) {
+      selectionCallback('install_smoke')
+    }
+    setSelectionCallback(null)
+  }, [selectionCallback])
+
+  // Close dialog without selection
+  const closeDialog = useCallback(() => {
+    setSelectionState({ visible: false, gameId: null, gameTitle: null })
+    setSelectionCallback(null)
+  }, [])
+
+  return {
+    selectionState,
+    showUnlockerSelection,
+    handleSelectCreamLinux,
+    handleSelectSmokeAPI,
+    closeDialog,
+  }
+}

src/styles/components/buttons/_button.scss

@@ -160,3 +160,33 @@
     transform: rotate(360deg);
   }
 }
+
+// Rating button on game card
+.rate-button {
+  svg {
+    color: var(--elevated-bg);
+    transition: transform var(--duration-normal) var(--easing-ease-out);
+  }
+
+  &:hover {
+    background-color: rgba(255, 255, 255, 0.28);
+    transform: translateY(-2px);
+    box-shadow: 0 7px 15px rgba(0, 0, 0, 0.25);
+
+    svg {
+      transform: scale(1.1);
+    }
+  }
+
+  &:active {
+    transform: translateY(0);
+    box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2);
+  }
+
+  &:disabled {
+    opacity: 0.4;
+    cursor: not-allowed;
+    transform: none;
+    box-shadow: none;
+  }
+}

src/styles/components/common/_dropdown.scss

@@ -0,0 +1,127 @@
+@use '../../themes/index' as *;
+@use '../../abstracts/index' as *;
+
+/* 
+  Dropdown component styles
+*/
+
+.dropdown-container {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+  width: 100%;
+}
+
+.dropdown-label-container {
+  display: flex;
+  flex-direction: column;
+  gap: 0.25rem;
+}
+
+.dropdown-label {
+  font-size: 0.95rem;
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.dropdown-description {
+  font-size: 0.85rem;
+  color: var(--text-secondary);
+  line-height: 1.4;
+  margin: 0;
+}
+
+.dropdown {
+  position: relative;
+  width: 100%;
+
+  &.disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+  }
+}
+
+.dropdown-trigger {
+  width: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  background-color: var(--border-dark);
+  border: 1px solid var(--border-soft);
+  border-radius: var(--radius-sm);
+  padding: 0.75rem 1rem;
+  color: var(--text-primary);
+  cursor: pointer;
+  transition: all var(--duration-normal) var(--easing-ease-out);
+
+  &:hover:not(:disabled) {
+    border-color: var(--border);
+    background-color: rgba(255, 255, 255, 0.05);
+  }
+
+  &:focus {
+    outline: none;
+    border-color: var(--primary-color);
+    box-shadow: 0 0 0 2px rgba(var(--primary-color), 0.2);
+  }
+
+  &:disabled {
+    cursor: not-allowed;
+  }
+}
+
+.dropdown-value {
+  flex: 1;
+  text-align: left;
+  font-size: 0.9rem;
+}
+
+.dropdown-icon {
+  transition: transform var(--duration-normal) var(--easing-ease-out);
+  color: var(--text-secondary);
+  transform: rotate(180deg);
+
+  &.open {
+    transform: rotate(0deg);
+  }
+}
+
+.dropdown-menu {
+  position: absolute;
+  top: calc(100% + 0.5rem);
+  left: 0;
+  right: 0;
+  background-color: var(--elevated-bg);
+  border: 1px solid var(--border-soft);
+  border-radius: var(--radius-sm);
+  box-shadow: var(--shadow-lg);
+  z-index: var(--z-modal);
+  max-height: 200px;
+  overflow-y: auto;
+  @include custom-scrollbar;
+}
+
+.dropdown-option {
+  width: 100%;
+  padding: 0.75rem 1rem;
+  background: none;
+  border: none;
+  color: var(--text-primary);
+  text-align: left;
+  cursor: pointer;
+  transition: all var(--duration-normal) var(--easing-ease-out);
+  font-size: 0.9rem;
+
+  &:hover {
+    background-color: rgba(255, 255, 255, 0.05);
+  }
+
+  &.selected {
+    background-color: rgba(var(--primary-color), 0.2);
+    color: var(--primary-color);
+  }
+
+  &:not(:last-child) {
+    border-bottom: 1px solid var(--border-soft);
+  }
+}

src/styles/components/common/_index.scss

@@ -1,2 +1,4 @@
 @forward './loading';
 @forward './progress_bar';
+@forward './dropdown';
+@forward './votes_display';

src/styles/components/common/_votes_display.scss

@@ -0,0 +1,43 @@
+@use '../../themes/index' as *;
+@use '../../abstracts/index' as *;
+
+.unlocker-votes {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  margin-top: 0.35rem;
+  margin-bottom: 0.35rem;
+
+  .votes-bar-wrap {
+    flex: 1;
+    height: 6px;
+    background-color: var(--border-soft);
+    border-radius: 99px;
+    overflow: hidden;
+
+    .votes-bar-fill {
+      height: 100%;
+      background-color: var(--success);
+      border-radius: 99px;
+      transition: width 0.4s ease;
+    }
+  }
+
+  .votes-label {
+    font-size: 0.75rem;
+    white-space: nowrap;
+    color: var(--text-muted);
+
+    &.votes-label--positive {
+      color: var(--success);
+    }
+
+    &.votes-label--negative {
+      color: var(--danger);
+    }
+
+    &.votes-label--none {
+      color: var(--text-muted);
+    }
+  }
+}

src/styles/components/dialogs/_conflict_dialog.scss

@@ -0,0 +1,143 @@
+@use '../../themes/index' as *;
+@use '../../abstracts/index' as *;
+
+/* 
+  Conflict Dialog Styles
+  Used for platform conflict detection dialogs
+*/
+
+.conflict-dialog-header {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+
+  h3 {
+    margin: 0;
+    flex: 1;
+    font-size: 1.1rem;
+    color: var(--text-primary);
+  }
+
+  svg {
+    color: var(--warning);
+    flex-shrink: 0;
+  }
+}
+
+.conflict-dialog-body {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+
+  .conflict-intro {
+    margin: 0;
+    color: var(--text-secondary);
+    line-height: 1.5;
+  }
+
+  .conflict-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.75rem;
+  }
+
+  .conflict-item {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 1rem;
+    padding: 1rem;
+    background: rgba(255, 255, 255, 0.03);
+    border: 1px solid rgba(255, 255, 255, 0.1);
+    border-radius: 8px;
+    transition: all 0.2s ease;
+
+    &:hover {
+      background: rgba(255, 255, 255, 0.05);
+      border-color: rgba(255, 255, 255, 0.15);
+    }
+  }
+
+  .conflict-info {
+    display: flex;
+    align-items: flex-start;
+    gap: 0.75rem;
+    flex: 1;
+    min-width: 0; // Enable text truncation
+  }
+
+  .conflict-icon {
+    flex-shrink: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 40px;
+    height: 40px;
+    background: rgba(255, 193, 7, 0.1);
+    border-radius: 8px;
+
+    svg {
+      color: var(--warning);
+    }
+  }
+
+  .conflict-details {
+    flex: 1;
+    min-width: 0;
+
+    h4 {
+      margin: 0 0 0.25rem 0;
+      font-size: 0.95rem;
+      font-weight: var(--semibold);
+      color: var(--text-primary);
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+
+    p {
+      margin: 0;
+      font-size: 0.85rem;
+      color: var(--text-secondary);
+      line-height: 1.4;
+    }
+  }
+
+  .conflict-resolve-btn {
+    flex-shrink: 0;
+    min-width: 100px;
+  }
+}
+
+.conflict-reminder {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  padding: 0.75rem 1rem;
+  background: rgba(33, 150, 243, 0.1);
+  border: 1px solid rgba(33, 150, 243, 0.2);
+  border-radius: 6px;
+  font-size: 0.85rem;
+  color: var(--text-secondary);
+  line-height: 1.4;
+  margin-bottom: 1rem;
+
+  svg {
+    color: var(--info);
+    flex-shrink: 0;
+  }
+
+  span {
+    flex: 1;
+  }
+
+  code {
+    padding: 0.125rem 0.375rem;
+    background: rgba(0, 0, 0, 0.3);
+    border-radius: 3px;
+    font-family: 'Courier New', monospace;
+    font-size: 0.8rem;
+    color: var(--text-primary);
+    white-space: nowrap;
+  }
+}

src/styles/components/dialogs/_disclaimer_dialog.scss

@@ -0,0 +1,38 @@
+@use '../../themes/index' as *;
+@use '../../abstracts/index' as *;
+
+/* 
+  Disclaimer Dialog Styles
+  Used for the startup disclaimer dialog
+*/
+
+.disclaimer-header {
+  h3 {
+    margin-bottom: 0;
+  }
+}
+.disclaimer-content {
+  p {
+    margin-bottom: 1rem;
+    color: var(--text-secondary);
+    line-height: 1.6;
+    font-size: 0.95rem;
+
+    &:last-of-type {
+      margin-bottom: 0;
+    }
+
+    strong {
+      color: var(--text-primary);
+      font-weight: var(--bold);
+    }
+  }
+}
+
+.disclaimer-footer {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  gap: 1rem;
+  width: 100%;
+}

src/styles/components/dialogs/_dlc_dialog.scss

@@ -154,6 +154,40 @@
   color: var(--text-secondary);
 }
 
+// Update results message
+.dlc-update-results {
+  padding: 0.75rem 1.5rem;
+  background-color: var(--elevated-bg);
+  border: 1px solid var(--border-soft);
+  border-radius: var(--radius-sm);
+  margin-bottom: 0.75rem;
+
+  .update-message {
+    color: var(--text-primary);
+    font-weight: 600;
+    font-size: 0.9rem;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+  }
+
+  &.dlc-update-success {
+    .update-message {
+      .dlc-update-icon-success {
+        color: var(--success);
+      }
+    }
+  }
+
+  &.dlc-update-info {
+    .update-message {
+      .dlc-update-icon-info {
+        color: var(--info);
+      }
+    }
+  }
+}
+
 // Game information in DLC dialog
 .dlc-game-info {
   display: flex;
@@ -175,6 +209,51 @@
   }
 }
 
+// Add DLC manually form
+.add-dlc-form {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+}
+
+.add-dlc-field {
+  display: flex;
+  flex-direction: column;
+  gap: 0.4rem;
+}
+
+.add-dlc-label {
+  font-size: 0.85rem;
+  color: var(--text-secondary);
+  font-weight: 500;
+}
+
+.add-dlc-input {
+  background-color: var(--border-dark);
+  border: 1px solid var(--border-soft);
+  border-radius: 4px;
+  color: var(--text-primary);
+  padding: 0.6rem 1rem;
+  font-size: 0.9rem;
+  transition: all var(--duration-normal) var(--easing-ease-out);
+
+  &:focus {
+    border-color: var(--primary-color);
+    outline: none;
+    box-shadow: 0px 0px 6px rgba(245, 150, 130, 0.2);
+  }
+
+  &::placeholder {
+    color: var(--text-muted);
+  }
+}
+
+.add-dlc-error {
+  font-size: 0.82rem;
+  color: var(--error);
+  margin: 0;
+}
+
 // Loading animations
 @keyframes spin {
   0% {

src/styles/components/dialogs/_index.scss

@@ -2,3 +2,10 @@
 @forward './dlc_dialog';
 @forward './progress_dialog';
 @forward './settings_dialog';
+@forward './smokeapi_settings_dialog';
+@forward './conflict_dialog';
+@forward './disclaimer_dialog';
+@forward './unlocker_selection_dialog';
+@forward './optin_dialog';
+@forward './rating_dialog';
+@forward './smokeapi_votes_dialog';

src/styles/components/dialogs/_optin_dialog.scss

@@ -0,0 +1,84 @@
+@use '../../themes/index' as *;
+@use '../../abstracts/index' as *;
+
+.optin-content {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+
+  .optin-icon-row {
+    display: flex;
+    justify-content: center;
+    color: var(--info);
+    margin-bottom: 0.25rem;
+  }
+
+  .optin-intro {
+    color: var(--text-secondary);
+    line-height: 1.55;
+    margin: 0;
+  }
+
+  .optin-details {
+    background-color: var(--border-dark);
+    border: 1px solid var(--border-soft);
+    border-radius: var(--radius-sm);
+    padding: 0.85rem 1rem;
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+
+    h4 {
+      margin: 0.4rem 0 0.2rem;
+      font-size: 0.85rem;
+      font-weight: var(--bold);
+      color: var(--text-secondary);
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+
+      &:first-child {
+        margin-top: 0;
+      }
+    }
+
+    ul {
+      margin: 0;
+      padding-left: 1.2rem;
+      display: flex;
+      flex-direction: column;
+      gap: 0.3rem;
+
+      li {
+        font-size: 0.88rem;
+        color: var(--text-secondary);
+        line-height: 1.45;
+
+        strong {
+          color: var(--text-primary);
+        }
+
+        em {
+          color: var(--text-muted);
+        }
+      }
+    }
+  }
+
+  .optin-notice {
+    display: flex;
+    align-items: flex-start;
+    gap: 0.5rem;
+    background-color: var(--info-soft);
+    border-radius: var(--radius-sm);
+    padding: 0.65rem 0.85rem;
+    font-size: 0.83rem;
+    color: var(--text-secondary);
+    line-height: 1.45;
+
+    svg {
+      flex-shrink: 0;
+      color: var(--info);
+      margin-top: 0.1rem;
+    }
+  }
+}

src/styles/components/dialogs/_rating_dialog.scss

@@ -0,0 +1,97 @@
+@use '../../themes/index' as *;
+@use '../../abstracts/index' as *;
+
+.rating-content {
+  display: flex;
+  flex-direction: column;
+  gap: 0.85rem;
+
+  p {
+    margin: 0;
+    color: var(--text-secondary);
+    line-height: 1.5;
+
+    strong {
+      color: var(--text-primary);
+    }
+  }
+
+  .rating-subtext {
+    font-size: 0.85rem;
+    color: var(--text-muted);
+  }
+}
+
+.rating-buttons {
+  display: flex;
+  gap: 0.75rem;
+  margin: 0.25rem 0;
+}
+
+.rating-btn {
+  flex: 1;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.4rem;
+  padding: 0.7rem 1rem;
+  border: none;
+  border-radius: var(--radius-sm);
+  font-size: 0.95rem;
+  font-weight: var(--bold);
+  cursor: pointer;
+  transition: all var(--duration-normal) var(--easing-ease-out);
+  color: var(--text-heavy);
+
+  &--worked {
+    background-color: var(--success);
+
+    &:hover:not(:disabled) {
+      background-color: var(--success-light);
+      transform: translateY(-2px);
+      box-shadow: 0 6px 14px rgba(140, 200, 147, 0.3);
+    }
+  }
+
+  &--broken {
+    background-color: var(--danger);
+
+    &:hover:not(:disabled) {
+      background-color: var(--danger-light);
+      transform: translateY(-2px);
+      box-shadow: 0 6px 14px rgba(217, 107, 107, 0.3);
+    }
+  }
+
+  &:active:not(:disabled) {
+    transform: scale(0.97);
+  }
+
+  &:disabled {
+    opacity: 0.6;
+    cursor: not-allowed;
+    transform: none;
+  }
+}
+
+.rating-notice {
+  display: flex;
+  align-items: center;
+  gap: 0.4rem;
+  font-size: 0.8rem;
+  color: var(--text-muted);
+
+  svg {
+    flex-shrink: 0;
+    color: var(--info);
+  }
+}
+
+.rating-submitted {
+  p {
+    margin: 0;
+    color: var(--text-secondary);
+    text-align: center;
+    padding: 0.5rem 0;
+  }
+}

src/styles/components/dialogs/_settings_dialog.scss

@@ -18,8 +18,8 @@
 
 .settings-section {
   h4 {
-    font-size: 1.1rem;
-    font-weight: 600;
+    font-size: 1.2rem;
+    font-weight: 700;
     color: var(--text-primary);
     margin-bottom: 0.5rem;
     padding-bottom: 0.5rem;

src/styles/components/dialogs/_smokeapi_settings_dialog.scss

@@ -0,0 +1,66 @@
+@use '../../themes/index' as *;
+@use '../../abstracts/index' as *;
+
+/* 
+  SmokeAPI Settings Dialog styles
+*/
+
+.dialog-subtitle {
+  color: var(--text-secondary);
+  font-weight: 500;
+  margin-top: 0.25rem;
+  font-weight: normal;
+}
+
+.smokeapi-settings-content {
+  display: flex;
+  flex-direction: column;
+  gap: 1.5rem;
+}
+
+.settings-options {
+  display: flex;
+  flex-direction: column;
+  gap: 1.5rem;
+  transition: opacity var(--duration-normal) var(--easing-ease-out);
+
+  &.disabled {
+    opacity: 0.4;
+    pointer-events: none;
+  }
+}
+
+.settings-section {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+
+  h4 {
+    font-size: 1rem;
+    font-weight: 600;
+    color: var(--text-primary);
+    margin: 0;
+    padding-bottom: 0.5rem;
+    border-bottom: 1px solid var(--border-soft);
+  }
+}
+
+.checkbox-option {
+  padding: 0.5rem 0;
+
+  &:not(:last-child) {
+    border-bottom: 1px solid var(--border-soft);
+  }
+
+  .animated-checkbox {
+    width: 100%;
+
+    .checkbox-content {
+      flex: 1;
+    }
+
+    .checkbox-sublabel {
+      margin-top: 0.25rem;
+    }
+  }
+}

src/styles/components/dialogs/_smokeapi_votes_dialog.scss

@@ -0,0 +1,57 @@
+@use '../../themes/index' as *;
+@use '../../abstracts/index' as *;
+
+.smokeapi-votes-content {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+
+  .smokeapi-votes-game {
+    margin: 0;
+    color: var(--text-secondary);
+
+    strong {
+      color: var(--text-primary);
+    }
+  }
+
+  .smokeapi-votes-section {
+    background-color: var(--border-dark);
+    border: 1px solid var(--border-soft);
+    border-radius: var(--radius-sm);
+    padding: 0.85rem 1rem;
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+  }
+
+  .smokeapi-votes-label {
+    margin: 0;
+    font-size: 0.8rem;
+    font-weight: var(--bold);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    color: var(--text-muted);
+  }
+
+  .smokeapi-votes-loading {
+    margin: 0;
+    font-size: 0.85rem;
+    color: var(--text-muted);
+  }
+
+  .smokeapi-votes-notice {
+    display: flex;
+    align-items: flex-start;
+    gap: 0.5rem;
+    font-size: 0.83rem;
+    color: var(--text-muted);
+    line-height: 1.45;
+
+    svg {
+      flex-shrink: 0;
+      color: var(--info);
+      margin-top: 0.1rem;
+    }
+  }
+}

src/styles/components/dialogs/_unlocker_selection_dialog.scss

@@ -0,0 +1,122 @@
+@use '../../themes/index' as *;
+@use '../../abstracts/index' as *;
+
+/* 
+  Unlocker Selection Dialog styles
+  For choosing between CreamLinux and SmokeAPI on native games
+*/
+
+.unlocker-selection-header {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+
+  h3 {
+    margin: 0;
+    font-size: 1.5rem;
+    font-weight: 600;
+    color: var(--text-primary);
+  }
+}
+
+.unlocker-selection-content {
+  display: flex;
+  flex-direction: column;
+  gap: 1.5rem;
+
+  .game-title-info {
+    font-size: 1rem;
+    color: var(--text-secondary);
+    margin: 0;
+
+    strong {
+      color: var(--text-primary);
+    }
+  }
+
+  .unlocker-options {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+  }
+
+  .unlocker-option {
+    background-color: rgba(255, 255, 255, 0.03);
+    border: 1px solid var(--border-soft);
+    border-radius: 8px;
+    padding: 1.25rem;
+    transition: all var(--duration-normal) var(--easing-ease-out);
+
+    &:hover {
+      background-color: rgba(255, 255, 255, 0.05);
+      border-color: var(--border);
+    }
+
+    &.recommended {
+      border-color: var(--primary-color);
+      background-color: rgba(245, 150, 130, 0.05);
+
+      &:hover {
+        background-color: rgba(245, 150, 130, 0.08);
+      }
+    }
+
+    .option-header {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      margin-bottom: 0.75rem;
+
+      h4 {
+        margin: 0;
+        font-size: 1.1rem;
+        font-weight: 600;
+        color: var(--text-primary);
+      }
+
+      .recommended-badge {
+        background-color: var(--primary-color);
+        color: var(--text-heavy);
+        padding: 0.25rem 0.75rem;
+        border-radius: 12px;
+        font-size: 0.75rem;
+        font-weight: 600;
+        text-transform: uppercase;
+      }
+
+      .alternative-badge {
+        background-color: var(--border);
+        color: var(--text-secondary);
+        padding: 0.25rem 0.75rem;
+        border-radius: 12px;
+        font-size: 0.75rem;
+        font-weight: 600;
+        text-transform: uppercase;
+      }
+    }
+
+    .option-description {
+      font-size: 0.9rem;
+      color: var(--text-secondary);
+      margin: 0 0 1rem 0;
+      line-height: 1.5;
+    }
+  }
+
+  .selection-info {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.75rem 1rem;
+    background-color: rgba(255, 255, 255, 0.02);
+    border: 1px solid var(--border-soft);
+    border-radius: 6px;
+    font-size: 0.85rem;
+    color: var(--text-muted);
+
+    svg {
+      flex-shrink: 0;
+      color: var(--info);
+    }
+  }
+}

src/types/Config.ts

@@ -0,0 +1,10 @@
+/**
+ * User configuration structure
+ * Matches the Rust Config struct
+ */
+export interface Config {
+  /** Whether to show the disclaimer on startup */
+  show_disclaimer: boolean
+  reporting_opted_in: boolean
+  reporting_has_seen_prompt: boolean
+}

src/types/index.ts

@@ -1,2 +1,3 @@
 export * from './Game'
 export * from './DlcInfo'
+export * from './Config'

tsconfig.app.json

@@ -1,5 +1,6 @@
 {
   "compilerOptions": {
+    "types": ["node"],
     "baseUrl": ".",
     "paths": {
       "@/*": ["src/*"]