diff --git a/crates/lanspread-tauri-deno-ts/src-tauri/src/lib.rs b/crates/lanspread-tauri-deno-ts/src-tauri/src/lib.rs
index b61f239..7794959 100644
--- a/crates/lanspread-tauri-deno-ts/src-tauri/src/lib.rs
+++ b/crates/lanspread-tauri-deno-ts/src-tauri/src/lib.rs
@@ -63,10 +63,17 @@ struct UiActiveOperation {
 
 #[derive(Clone, Debug, serde::Serialize)]
 struct GamesListPayload {
-    games: Vec<Game>,
+    games: Vec<LauncherGame>,
     active_operations: Vec<UiActiveOperation>,
 }
 
+#[derive(Clone, Debug, serde::Serialize)]
+struct LauncherGame {
+    #[serde(flatten)]
+    game: Game,
+    can_host_server: bool,
+}
+
 #[derive(Clone, Debug, serde::Serialize)]
 struct UnpackLogEntry {
     archive: String,
@@ -104,6 +111,17 @@ async fn get_unpack_logs(
 
 #[cfg(target_os = "windows")]
 const FIRST_START_DONE_FILE: &str = ".softlan_first_start_done";
+#[cfg_attr(not(target_os = "windows"), allow(dead_code))]
+const GAME_SETUP_SCRIPT: &str = "game_setup.cmd";
+#[cfg_attr(not(target_os = "windows"), allow(dead_code))]
+const GAME_START_SCRIPT: &str = "game_start.cmd";
+const SERVER_START_SCRIPT: &str = "server_start.cmd";
+#[cfg_attr(not(target_os = "windows"), allow(dead_code))]
+const DEFAULT_LANGUAGE: &str = "en";
+#[cfg_attr(not(target_os = "windows"), allow(dead_code))]
+const DEFAULT_USERNAME: &str = "Commander";
+#[cfg_attr(not(target_os = "windows"), allow(dead_code))]
+const MAX_USERNAME_CHARS: usize = 24;
 
 #[tauri::command]
 async fn request_games(state: tauri::State<'_, LanSpreadState>) -> tauri::Result<()> {
@@ -381,6 +399,57 @@ fn is_single_component_game_id(id: &str) -> bool {
     matches!(components.next(), Some(Component::Normal(_))) && components.next().is_none()
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[cfg_attr(not(target_os = "windows"), allow(dead_code))]
+struct LaunchSettings {
+    language: String,
+    username: String,
+}
+
+#[cfg_attr(not(target_os = "windows"), allow(dead_code))]
+fn launch_settings(language: &str, username: &str) -> LaunchSettings {
+    LaunchSettings {
+        language: sanitize_language(language),
+        username: sanitize_username(username),
+    }
+}
+
+#[cfg_attr(not(target_os = "windows"), allow(dead_code))]
+fn sanitize_language(language: &str) -> String {
+    match language.trim().to_ascii_lowercase().as_str() {
+        "de" => "de".to_string(),
+        "en" => "en".to_string(),
+        _ => DEFAULT_LANGUAGE.to_string(),
+    }
+}
+
+#[cfg_attr(not(target_os = "windows"), allow(dead_code))]
+fn sanitize_username(username: &str) -> String {
+    let cleaned = username
+        .trim()
+        .chars()
+        .filter(|c| !c.is_control() && *c != '"' && *c != '%')
+        .take(MAX_USERNAME_CHARS)
+        .collect::<String>();
+
+    if cleaned.is_empty() {
+        DEFAULT_USERNAME.to_string()
+    } else {
+        cleaned
+    }
+}
+
+#[cfg_attr(not(target_os = "windows"), allow(dead_code))]
+fn script_params(script_path: &Path, id: &str, settings: &LaunchSettings) -> String {
+    format!(
+        r#"/d /s /c ""{}" "local" "{}" "{}" "{}"""#,
+        script_path.display(),
+        id,
+        settings.language,
+        settings.username,
+    )
+}
+
 #[tauri::command]
 async fn get_peer_count(state: tauri::State<'_, LanSpreadState>) -> tauri::Result<usize> {
     let peer_ctrl_arc = state.inner().peer_ctrl.clone();
@@ -445,8 +514,16 @@ fn run_as_admin(file: &str, params: &str, dir: &str) -> bool {
 #[cfg(target_os = "windows")]
 async fn run_game_windows(
     id: String,
+    language: String,
+    username: String,
     state: tauri::State<'_, LanSpreadState>,
 ) -> tauri::Result<()> {
+    if !is_single_component_game_id(&id) {
+        log::warn!("Ignoring run request for invalid game id: {id}");
+        return Ok(());
+    }
+
+    let settings = launch_settings(&language, &username);
     let games_folder_lock = state.inner().games_folder.clone();
     let games_folder = {
         let guard = games_folder_lock.read().await;
@@ -461,8 +538,8 @@ async fn run_game_windows(
 
     let game_path = games_folder.join(id.clone());
 
-    let game_setup_bin = game_path.join("game_setup.cmd");
-    let game_start_bin = game_path.join("game_start.cmd");
+    let game_setup_bin = game_path.join(GAME_SETUP_SCRIPT);
+    let game_start_bin = game_path.join(GAME_START_SCRIPT);
 
     let first_start_done_file = game_path.join("local").join(FIRST_START_DONE_FILE);
     if !first_start_done_file.exists() && game_setup_bin.exists() {
@@ -476,16 +553,12 @@ async fn run_game_windows(
 
         let result = run_as_admin(
             "cmd.exe",
-            &format!(
-                r#"/c "{} local {} de playername""#,
-                game_setup_bin.display(),
-                &id
-            ),
+            &script_params(&game_setup_bin, &id, &settings),
             &game_path.display().to_string(),
         );
 
         if !result {
-            log::error!("failed to run game_setup.cmd");
+            log::error!("failed to run {GAME_SETUP_SCRIPT}");
             return Ok(());
         }
 
@@ -500,16 +573,12 @@ async fn run_game_windows(
     if game_start_bin.exists() {
         let result = run_as_admin(
             "cmd.exe",
-            &format!(
-                r#"/c "{} local {} de playername""#,
-                game_start_bin.display(),
-                &id
-            ),
+            &script_params(&game_start_bin, &id, &settings),
             &game_path.display().to_string(),
         );
 
         if !result {
-            log::error!("failed to run game_start.cmd");
+            log::error!("failed to run {GAME_START_SCRIPT}");
         }
     }
 
@@ -517,21 +586,97 @@ async fn run_game_windows(
 }
 
 #[tauri::command]
-async fn run_game(id: String, state: tauri::State<'_, LanSpreadState>) -> tauri::Result<()> {
+async fn run_game(
+    id: String,
+    language: String,
+    username: String,
+    state: tauri::State<'_, LanSpreadState>,
+) -> tauri::Result<()> {
     #[cfg(target_os = "windows")]
     {
-        run_game_windows(id, state).await?;
+        run_game_windows(id, language, username, state).await?;
     }
 
     #[cfg(not(target_os = "windows"))]
     {
-        let _ = state;
+        let _ = (state, language, username);
         log::error!("run_game not implemented for this platform: id={id}");
     }
 
     Ok(())
 }
 
+#[cfg(target_os = "windows")]
+async fn start_server_windows(
+    id: String,
+    language: String,
+    username: String,
+    state: tauri::State<'_, LanSpreadState>,
+) -> tauri::Result<bool> {
+    if !is_single_component_game_id(&id) {
+        log::warn!("Ignoring server start request for invalid game id: {id}");
+        return Ok(false);
+    }
+
+    let settings = launch_settings(&language, &username);
+    let games_folder = PathBuf::from(state.inner().games_folder.read().await.clone());
+    if !games_folder.exists() {
+        log::error!("games_folder {} does not exist", games_folder.display());
+        return Ok(false);
+    }
+
+    let game_path = games_folder.join(id.clone());
+    if !local_install_is_present(&game_path) {
+        log::warn!(
+            "local install is missing for {}; skipping {SERVER_START_SCRIPT}",
+            game_path.display()
+        );
+        return Ok(false);
+    }
+
+    let server_start_bin = game_path.join(SERVER_START_SCRIPT);
+    if !server_start_bin.is_file() {
+        log::warn!(
+            "server start script is missing for {}: {}",
+            id,
+            server_start_bin.display()
+        );
+        return Ok(false);
+    }
+
+    let result = run_as_admin(
+        "cmd.exe",
+        &script_params(&server_start_bin, &id, &settings),
+        &game_path.display().to_string(),
+    );
+
+    if !result {
+        log::error!("failed to run {SERVER_START_SCRIPT}");
+    }
+
+    Ok(result)
+}
+
+#[tauri::command]
+async fn start_server(
+    id: String,
+    language: String,
+    username: String,
+    state: tauri::State<'_, LanSpreadState>,
+) -> tauri::Result<bool> {
+    #[cfg(target_os = "windows")]
+    {
+        start_server_windows(id, language, username, state).await
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    {
+        let _ = (state, language, username);
+        log::error!("start_server not implemented for this platform: id={id}");
+        Ok(false)
+    }
+}
+
 #[cfg(target_os = "windows")]
 fn local_install_is_present(game_path: &Path) -> bool {
     game_path.join("local").is_dir()
@@ -592,6 +737,7 @@ async fn emit_games_list(app_handle: &AppHandle) {
 
     let games_db_lock = state.games.clone();
     let game_db = games_db_lock.read().await;
+    let games_folder = state.games_folder.read().await.clone();
 
     if game_db.games.is_empty() {
         log::debug!("Game database empty; skipping emit");
@@ -602,7 +748,11 @@ async fn emit_games_list(app_handle: &AppHandle) {
         .all_games()
         .into_iter()
         .cloned()
-        .collect::<Vec<Game>>();
+        .map(|game| LauncherGame {
+            can_host_server: game_can_host_server(&games_folder, &game),
+            game,
+        })
+        .collect::<Vec<LauncherGame>>();
 
     drop(game_db);
 
@@ -623,6 +773,17 @@ async fn emit_games_list(app_handle: &AppHandle) {
     }
 }
 
+fn game_can_host_server(games_folder: &str, game: &Game) -> bool {
+    if !game.installed || games_folder.is_empty() || !is_single_component_game_id(&game.id) {
+        return false;
+    }
+
+    PathBuf::from(games_folder)
+        .join(&game.id)
+        .join(SERVER_START_SCRIPT)
+        .is_file()
+}
+
 fn ui_active_operations_from_map(
     active_operations: &HashMap<String, UiOperationKind>,
 ) -> Vec<UiActiveOperation> {
@@ -1440,6 +1601,68 @@ mod tests {
         assert!(!is_single_component_game_id("/game"));
     }
 
+    #[test]
+    fn launch_settings_sanitize_script_arguments() {
+        assert_eq!(
+            launch_settings("DE", "  Alice \"Ace\"%PATH%\n  "),
+            LaunchSettings {
+                language: "de".to_string(),
+                username: "Alice AcePATH".to_string(),
+            }
+        );
+        assert_eq!(
+            launch_settings("fr", ""),
+            LaunchSettings {
+                language: DEFAULT_LANGUAGE.to_string(),
+                username: DEFAULT_USERNAME.to_string(),
+            }
+        );
+    }
+
+    #[test]
+    fn script_params_use_common_argument_shape() {
+        let params = script_params(
+            Path::new("C:/Games/My Game")
+                .join(GAME_START_SCRIPT)
+                .as_path(),
+            "my-game",
+            &LaunchSettings {
+                language: "en".to_string(),
+                username: "Alice".to_string(),
+            },
+        );
+
+        assert_eq!(
+            params,
+            r#"/d /s /c ""C:/Games/My Game/game_start.cmd" "local" "my-game" "en" "Alice"""#
+        );
+    }
+
+    #[test]
+    fn server_host_capability_requires_installed_game_with_script() {
+        let root = std::env::temp_dir().join(format!(
+            "lanspread-server-test-{}",
+            SystemTime::now()
+                .duration_since(UNIX_EPOCH)
+                .expect("clock should be after epoch")
+                .as_nanos()
+        ));
+        let game_root = root.join("game");
+        std::fs::create_dir_all(&game_root).expect("game root should be created");
+        std::fs::write(game_root.join(SERVER_START_SCRIPT), b"").expect("script should be written");
+
+        let mut game = game_fixture("game", "Game");
+        assert!(!game_can_host_server(
+            root.to_string_lossy().as_ref(),
+            &game
+        ));
+
+        game.installed = true;
+        assert!(game_can_host_server(root.to_string_lossy().as_ref(), &game));
+
+        let _ = std::fs::remove_dir_all(root);
+    }
+
     #[test]
     fn peer_local_snapshot_replaces_local_state_without_overwriting_catalog_metadata() {
         let mut alpha = game_fixture("alpha", "Catalog Alpha");
@@ -1506,6 +1729,7 @@ pub fn run() {
             request_games,
             install_game,
             run_game,
+            start_server,
             update_game_directory,
             update_game,
             uninstall_game,
diff --git a/crates/lanspread-tauri-deno-ts/src/components/Icon.tsx b/crates/lanspread-tauri-deno-ts/src/components/Icon.tsx
index a8a6f7a..7231bea 100644
--- a/crates/lanspread-tauri-deno-ts/src/components/Icon.tsx
+++ b/crates/lanspread-tauri-deno-ts/src/components/Icon.tsx
@@ -21,6 +21,15 @@ export const Icon = {
             <path d="M4 2.5v11l10-5.5z" />
         </svg>
     ),
+    server: (p: Props) => (
+        <svg viewBox="0 0 16 16" width="13" height="13" strokeWidth={1.5} {...baseStroke} {...p}>
+            <rect x="2" y="3" width="12" height="4.5" rx="1" />
+            <rect x="2" y="8.5" width="12" height="4.5" rx="1" />
+            <circle cx="4.6" cy="5.25" r=".55" fill="currentColor" stroke="none" />
+            <circle cx="4.6" cy="10.75" r=".55" fill="currentColor" stroke="none" />
+            <path d="M7 5.25h4.5M7 10.75h4.5" />
+        </svg>
+    ),
     install: (p: Props) => (
         <svg viewBox="0 0 16 16" width="12" height="12" strokeWidth={1.7} {...baseStroke} {...p}>
             <path d="M8 2v8" />
diff --git a/crates/lanspread-tauri-deno-ts/src/components/modals/GameDetailModal.tsx b/crates/lanspread-tauri-deno-ts/src/components/modals/GameDetailModal.tsx
index 44e0579..52d1acb 100644
--- a/crates/lanspread-tauri-deno-ts/src/components/modals/GameDetailModal.tsx
+++ b/crates/lanspread-tauri-deno-ts/src/components/modals/GameDetailModal.tsx
@@ -16,6 +16,7 @@ interface Props {
     onUninstall: (game: Game) => void;
     onRemoveDownload: (game: Game) => void;
     onCancelDownload: (game: Game) => void;
+    onStartServer: (game: Game) => void;
     onViewFiles: (game: Game) => void;
 }
 
@@ -45,6 +46,7 @@ export const GameDetailModal = ({
     onUninstall,
     onRemoveDownload,
     onCancelDownload,
+    onStartServer,
     onViewFiles,
 }: Props) => {
     const tags = tagsFromGame(game);
@@ -116,6 +118,16 @@ export const GameDetailModal = ({
                         onClick={() => onPrimary(game)}
                         onCancelDownload={onCancelDownload}
                     />
+                    {game.installed && game.can_host_server === true && (
+                        <button
+                            type="button"
+                            className="act-btn act-lg act-server"
+                            onClick={() => onStartServer(game)}
+                        >
+                            <Icon.server />
+                            <span className="act-label">Start Server</span>
+                        </button>
+                    )}
                     {game.installed && (
                         <button
                             type="button"
diff --git a/crates/lanspread-tauri-deno-ts/src/components/modals/SettingsDialog.tsx b/crates/lanspread-tauri-deno-ts/src/components/modals/SettingsDialog.tsx
index 2719b78..58492bd 100644
--- a/crates/lanspread-tauri-deno-ts/src/components/modals/SettingsDialog.tsx
+++ b/crates/lanspread-tauri-deno-ts/src/components/modals/SettingsDialog.tsx
@@ -8,7 +8,8 @@ import {
     ASPECT_OPTIONS,
     BG_OPTIONS,
     DENSITY_OPTIONS,
-    UISettings,
+    LANGUAGE_OPTIONS,
+    type UISettings,
 } from '../../hooks/useSettings';
 
 interface Props {
@@ -33,6 +34,26 @@ const Row = ({ label, hint, children }: RowProps) => (
     </div>
 );
 
+interface TextInputProps {
+    value: string;
+    placeholder: string;
+    maxLength: number;
+    onChange: (value: string) => void;
+}
+
+const SettingsTextInput = ({ value, placeholder, maxLength, onChange }: TextInputProps) => (
+    <div className="settings-text">
+        <input
+            type="text"
+            value={value}
+            placeholder={placeholder}
+            maxLength={maxLength}
+            spellCheck={false}
+            onChange={(e) => onChange(e.target.value)}
+        />
+    </div>
+);
+
 export const SettingsDialog = ({ settings, onChange, onClose }: Props) => (
     <Modal onClose={onClose} className="settings-modal">
         <div className="settings-head">
@@ -48,6 +69,25 @@ export const SettingsDialog = ({ settings, onChange, onClose }: Props) => (
         </div>
 
         <div className="settings-body">
+            <section className="settings-section">
+                <div className="settings-section-title">Profile</div>
+                <Row label="Username" hint="Shown to other players on the LAN">
+                    <SettingsTextInput
+                        value={settings.username}
+                        placeholder="Enter a username"
+                        maxLength={24}
+                        onChange={(v) => onChange('username', v)}
+                    />
+                </Row>
+                <Row label="Language" hint="Interface language">
+                    <SegmentedRadio
+                        value={settings.language}
+                        options={LANGUAGE_OPTIONS}
+                        onChange={(v) => onChange('language', v)}
+                    />
+                </Row>
+            </section>
+
             <section className="settings-section">
                 <div className="settings-section-title">Appearance</div>
                 <Row label="Accent color" hint="Used for primary actions and highlights">
diff --git a/crates/lanspread-tauri-deno-ts/src/hooks/useGameActions.ts b/crates/lanspread-tauri-deno-ts/src/hooks/useGameActions.ts
index d8a0671..7f1e82f 100644
--- a/crates/lanspread-tauri-deno-ts/src/hooks/useGameActions.ts
+++ b/crates/lanspread-tauri-deno-ts/src/hooks/useGameActions.ts
@@ -1,10 +1,12 @@
 import { useCallback } from 'react';
 import { invoke } from '@tauri-apps/api/core';
 
-import { UseGamesResult } from './useGames';
+import { type UseGamesResult } from './useGames';
+import { type UISettings } from './useSettings';
 
 export interface GameActions {
     play: (id: string) => Promise<void>;
+    startServer: (id: string) => Promise<void>;
     install: (id: string) => Promise<void>;
     update: (id: string) => Promise<void>;
     uninstall: (id: string) => Promise<void>;
@@ -19,14 +21,33 @@ export interface GameActions {
  * are marked as "checking peers" until the backend emits an authoritative
  * operation snapshot; cancellation waits for the backend to clear that snapshot.
  */
-export const useGameActions = (games: UseGamesResult): GameActions => {
+export const useGameActions = (
+    games: UseGamesResult,
+    settings: Pick<UISettings, 'language' | 'username'>,
+): GameActions => {
     const play = useCallback(async (id: string) => {
         try {
-            await invoke('run_game', { id });
+            await invoke('run_game', {
+                id,
+                language: settings.language,
+                username: settings.username,
+            });
         } catch (err) {
             console.error('run_game failed:', err);
         }
-    }, []);
+    }, [settings.language, settings.username]);
+
+    const startServer = useCallback(async (id: string) => {
+        try {
+            await invoke('start_server', {
+                id,
+                language: settings.language,
+                username: settings.username,
+            });
+        } catch (err) {
+            console.error('start_server failed:', err);
+        }
+    }, [settings.language, settings.username]);
 
     const install = useCallback(async (id: string) => {
         try {
@@ -83,5 +104,5 @@ export const useGameActions = (games: UseGamesResult): GameActions => {
         }
     }, []);
 
-    return { play, install, update, uninstall, removeDownload, cancelDownload, viewFiles };
+    return { play, startServer, install, update, uninstall, removeDownload, cancelDownload, viewFiles };
 };
diff --git a/crates/lanspread-tauri-deno-ts/src/hooks/useSettings.ts b/crates/lanspread-tauri-deno-ts/src/hooks/useSettings.ts
index 07536e5..a1432d5 100644
--- a/crates/lanspread-tauri-deno-ts/src/hooks/useSettings.ts
+++ b/crates/lanspread-tauri-deno-ts/src/hooks/useSettings.ts
@@ -1,7 +1,7 @@
 import { useCallback, useEffect, useState } from 'react';
 import { load } from '@tauri-apps/plugin-store';
 
-import { GameFilter, GameSort } from '../lib/types';
+import { type GameFilter, type GameSort, type LauncherLanguage } from '../lib/types';
 import { SETTINGS_FILE, SETTINGS_FILE_OPTIONS, UI_SETTINGS_KEY } from '../lib/store';
 
 export type Density = 'compact' | 'normal' | 'large';
@@ -15,10 +15,14 @@ export interface UISettings {
     aspect: CoverAspect;
     sort: GameSort;
     filter: GameFilter;
+    username: string;
+    language: LauncherLanguage;
 }
 
 type StoredGameSort = GameSort | 'size';
 type StoredUISettings = Partial<Omit<UISettings, 'sort'> & { sort: StoredGameSort }>;
+const DEFAULT_USERNAME = 'Commander';
+const MAX_USERNAME_LENGTH = 24;
 
 export const ACCENT_OPTIONS = [
     { value: '#3b82f6', label: 'Blue' },
@@ -47,6 +51,18 @@ export const ASPECT_OPTIONS: ReadonlyArray<{ value: CoverAspect; label: string }
     { value: 'banner', label: 'Banner' },
 ];
 
+export const LANGUAGE_OPTIONS: ReadonlyArray<{ value: LauncherLanguage; label: string }> = [
+    { value: 'en', label: 'English' },
+    { value: 'de', label: 'Deutsch' },
+];
+
+const defaultLanguage = (): LauncherLanguage => {
+    if (typeof navigator !== 'undefined' && navigator.language.toLowerCase().startsWith('de')) {
+        return 'de';
+    }
+    return 'en';
+};
+
 export const DEFAULT_SETTINGS: UISettings = {
     accent: '#3b82f6',
     bg: 'gradient',
@@ -54,6 +70,8 @@ export const DEFAULT_SETTINGS: UISettings = {
     aspect: 'square',
     sort: 'status',
     filter: 'local',
+    username: DEFAULT_USERNAME,
+    language: defaultLanguage(),
 };
 
 const sanitize = (raw: StoredUISettings | undefined): UISettings => ({
@@ -63,12 +81,23 @@ const sanitize = (raw: StoredUISettings | undefined): UISettings => ({
     aspect: raw?.aspect ?? DEFAULT_SETTINGS.aspect,
     sort: sanitizeSort(raw?.sort),
     filter: raw?.filter ?? DEFAULT_SETTINGS.filter,
+    username: sanitizeUsername(raw?.username),
+    language: sanitizeLanguage(raw?.language),
 });
 
 const sanitizeSort = (sort: StoredGameSort | undefined): GameSort => (
     sort === 'size' ? 'sizeDesc' : sort ?? DEFAULT_SETTINGS.sort
 );
 
+const sanitizeLanguage = (language: LauncherLanguage | undefined): LauncherLanguage => (
+    language === 'de' || language === 'en' ? language : DEFAULT_SETTINGS.language
+);
+
+const sanitizeUsername = (username: string | undefined): string => {
+    const trimmed = username?.trim() ?? '';
+    return trimmed ? Array.from(trimmed).slice(0, MAX_USERNAME_LENGTH).join('') : DEFAULT_USERNAME;
+};
+
 export interface UseSettings {
     settings: UISettings;
     set: <K extends keyof UISettings>(key: K, value: UISettings[K]) => void;
diff --git a/crates/lanspread-tauri-deno-ts/src/lib/types.ts b/crates/lanspread-tauri-deno-ts/src/lib/types.ts
index 608c14a..3dc2d33 100644
--- a/crates/lanspread-tauri-deno-ts/src/lib/types.ts
+++ b/crates/lanspread-tauri-deno-ts/src/lib/types.ts
@@ -58,6 +58,7 @@ export interface Game {
     status_level?: StatusLevel;
     download_progress?: DownloadProgress;
     peer_count: number;
+    can_host_server?: boolean;
 }
 
 export interface ActiveOperation {
@@ -78,3 +79,6 @@ export type GameSort = 'az' | 'sizeDesc' | 'sizeAsc' | 'status';
 
 /** Visual state of a card. Derived from backend operation status and local flags. */
 export type DerivedState = 'installed' | 'local' | 'downloading' | 'none' | 'busy';
+
+/** Two-character language code passed through to game scripts. */
+export type LauncherLanguage = 'en' | 'de';
diff --git a/crates/lanspread-tauri-deno-ts/src/styles/launcher.css b/crates/lanspread-tauri-deno-ts/src/styles/launcher.css
index 2c10d3b..fa1667b 100644
--- a/crates/lanspread-tauri-deno-ts/src/styles/launcher.css
+++ b/crates/lanspread-tauri-deno-ts/src/styles/launcher.css
@@ -807,6 +807,20 @@
   background: rgba(255, 255, 255, 0.12);
   border-color: var(--bd-3);
 }
+.act-server {
+  color: var(--t-1);
+  background: color-mix(in srgb, var(--accent) 14%, rgba(255, 255, 255, 0.04));
+  border: 1px solid color-mix(in srgb, var(--accent) 55%, transparent);
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.06);
+}
+.act-server:hover:not(:disabled) {
+  background: color-mix(in srgb, var(--accent) 22%, rgba(255, 255, 255, 0.04));
+  border-color: color-mix(in srgb, var(--accent) 75%, transparent);
+  filter: none;
+}
+.act-server svg {
+  color: var(--accent);
+}
 .act-busy {
   color: var(--t-1);
   background: rgba(255, 255, 255, 0.06);
@@ -1475,6 +1489,43 @@
   filter: brightness(1.1);
 }
 
+/* Settings: text input */
+.settings-text {
+  display: inline-flex;
+  align-items: center;
+  width: 220px;
+  height: 36px;
+  padding: 0 12px;
+  background: var(--bg-3);
+  border: 1px solid var(--bd-1);
+  border-radius: 8px;
+  transition:
+    background 0.15s,
+    border-color 0.15s,
+    box-shadow 0.15s;
+}
+.settings-text:focus-within {
+  background: var(--bg-2);
+  border-color: var(--accent);
+  box-shadow: 0 0 0 3px color-mix(in srgb, var(--accent) 22%, transparent);
+}
+.settings-text input {
+  min-width: 0;
+  flex: 1;
+  background: transparent;
+  border: 0;
+  outline: 0;
+  color: var(--t-1);
+  font: inherit;
+  font-size: 13.5px;
+  font-weight: 600;
+  letter-spacing: 0;
+}
+.settings-text input::placeholder {
+  color: var(--t-3);
+  font-weight: 500;
+}
+
 /* Settings: color swatches */
 .swatch-row {
   display: inline-flex;
diff --git a/crates/lanspread-tauri-deno-ts/src/windows/MainWindow.tsx b/crates/lanspread-tauri-deno-ts/src/windows/MainWindow.tsx
index b4cacbd..837705c 100644
--- a/crates/lanspread-tauri-deno-ts/src/windows/MainWindow.tsx
+++ b/crates/lanspread-tauri-deno-ts/src/windows/MainWindow.tsx
@@ -47,7 +47,7 @@ export const MainWindow = () => {
     const { settings, set: setSetting } = useSettings();
     const { gameDir, setGameDir, rescan } = useGameDirectory();
     const games = useGames(rescan);
-    const actions = useGameActions(games);
+    const actions = useGameActions(games, settings);
     const thumbnails = useThumbnails();
 
     const [openGameId, setOpenGameId] = useState<string | null>(null);
@@ -172,6 +172,7 @@ export const MainWindow = () => {
                     onUninstall={handleUninstall}
                     onRemoveDownload={handleRemoveDownload}
                     onCancelDownload={(g) => actions.cancelDownload(g.id)}
+                    onStartServer={(g) => actions.startServer(g.id)}
                     onViewFiles={(g) => actions.viewFiles(g.id)}
                 />
             )}