@@ -2108,3 +2108,56 @@ stall → 1.8 s muted instead of a replay; a normal race mutes ~85 ms.
 `SPEED2.EXE` is checked by SHA-256 at startup; any other build (the US retail
 executable, for one) gets a clear message instead of a crash.
 `NFSU2_ANY_EXE=1` skips the check.
+
+## 2026-10-26: launcher window and portable copy
+
+Reddit asked for a GUI and for a single app with the game inside, made without a
+terminal. `launcher/*.swift` (Swift 5 mode, AppKit + SwiftUI, macOS 11 target)
+is now the bundle's executable; `pack.sh` builds it with `swiftc` and puts both
+engines next to it:
+
+    Contents/MacOS/NFSU2              launcher
+    Contents/MacOS/nfsu2-engine       out/nfsu2_boot
+    Contents/MacOS/nfsu2-engine-hd    out/nfsu2_hd_boot
+
+One download (~67 MB) instead of two apps. `./pack.sh --hd` still makes the old
+HD-only "NFSU2 HD.app"; `--original-only` leaves the HD engine out; without
+`swiftc` the engine becomes the executable as before (no window).
+
+- **Game files:** same search order as `app_find_game`; the exe is checked
+  (size, SHA-256) before Play; the engine gets the checked path in `NFSU2_DATA`.
+  States: found / not found / different version / inside this app.
+- **Graphics:** Original or HD (`LauncherEngine`), full screen (`NFSUFullScreen`,
+  the key the engine already uses).
+- **Make Copy…:** builds "NFSU2 Portable.app" (save panel, /Applications by
+  default): copies this bundle plus the game folder into
+  `Contents/Resources/Game` (MOVIES and the Windows plugins left out, as in
+  `pack.sh --embed`), `copyfile(COPYFILE_CLONE)` per file (instant on the same
+  APFS disk: measured 6 s for 1.5 GB), removes the quarantine tag, signs ad hoc
+  again, then renames from a hidden `.partial` name. The running app is never
+  written to (signature; App Translocation makes it read-only anyway). A copy
+  being replaced goes to the Trash.
+- **Tools:** Saves, Logs, Reset Graphics Settings (drops `g_*` and
+  `NotFirstTime` from `~/.nfsu2_registry`: the game detects again), Report a
+  Problem (GitHub issues).
+- **Show this window when the app opens:** off = straight into the game; hold
+  Option to see the window.
+
+**The engine is a child process, not exec().** A game folder under Downloads /
+Documents / Desktop triggers macOS's folder permission prompt. A child process
+inherits the launcher as its "responsible" process, so the permission granted to
+the launcher covers the engine; after exec() the ad-hoc signed engine would be a
+different code identity and could be asked again. The launcher hides its window,
+drops its Dock icon (accessory) and exits with the engine's exit status, so
+`open -W` still waits for the game.
+
+Test hooks (no visible window): `NFSU2_LAUNCHER_SNAPSHOT=<png>` draws the window
+(`NFSU2_LAUNCHER_STATE=notfound|unsupported|embedded|copying|done`),
+`NFSU2_LAUNCHER_TEST=play` presses Play off screen,
+`NFSU2_LAUNCHER_TEST=portable:<game dir>:<dest.app>` builds a portable copy.
+In automated runs keep the game outside Downloads/Documents/Desktop (or pass
+`NFSU2_DATA`): the permission prompt otherwise waits for a click.
+Verified: Original and HD started through `open` + launcher, 1200–1500 frames,
+clean exit, 0 traps; portable copy signed (`codesign --verify --strict`), no
+quarantine, runs from its embedded data; user prefs and registry unchanged.
+`tools/session.sh` opens NFSU2.app with `NFSU2_SKIP_LAUNCHER=1 NFSU2_ENGINE=…`.
@@ -17,9 +17,9 @@ time. On an M1 Pro, races run at **119 fps** (the display's limit), against
 
 > **This repository contains no game code and no game assets.** It contains the
 > recompiler and the runtime only. You need your own copy of the game. The C
-> code generated from its executable is never committed. The prebuilt apps on
-> the [Releases page](https://github.com/TalhaMudo/NFSU2Recomp/releases/latest) contain the recompiled program but no game files:
-> on first launch you point them at your own installation.
+> code generated from its executable is never committed. The prebuilt app on
+> the [Releases page](https://github.com/TalhaMudo/NFSU2Recomp/releases/latest) contains the recompiled program but no game files:
+> on first launch you point it at your own installation.
 
 ![Race, native ARM64 build](screenshots/selected/27_20260924_current-race.jpg)
 
@@ -35,7 +35,7 @@ The game boots, reaches the menus, and races are playable with sound.
 | DirectSound → CoreAudio, DirectInput (keyboard, mouse) | working |
 | Windowed, fullscreen, Retina-native and 1080p widescreen | working |
 | Career mode: profile creation (name entry), save and load | working |
-| Double-clickable `.app` (`./pack.sh`) | working |
+| Double-clickable `.app` with a launcher window (`./pack.sh`) | working |
 | Optional "HD" build: MSAA (2× at 1440 lines and above, 4× below), SSR, ray-traced reflections | working, see `GRAPHICS_RESEARCH.md` |
 
 ### Known limitations
@@ -107,6 +107,7 @@ out/nfsu2_boot            ~35 MB arm64 Mach-O
 | `runtime/overrides.c`, `d3dx_hle.c` | hand-written replacements for specific game functions |
 | `runtime/enhance.c` | HD build only (`-DNFS_ENHANCED=1`) |
 | `runtime/bundle.m`, `pack.sh` | `.app` behaviour and packaging |
+| `launcher/*.swift` | the app's launcher window (Swift/SwiftUI): finds and checks the game, Original/HD, portable copy |
 | `tests/boot.c` | program entry point (runs the game from its PE entry point) |
 
 ## Verification
@@ -149,7 +150,7 @@ HD build draws about 18 W.
 ## Requirements
 
 - Apple Silicon Mac, macOS 11 or later. Developed on an M1 Pro, macOS 27.
-- Xcode Command Line Tools (`clang`).
+- Xcode Command Line Tools (`clang`; `swiftc` for the launcher window).
 - Python 3 with `capstone` 5.x and `pefile` (`requirements.txt`).
 - Rosetta 2, only for `tools/fuzzisa.py`.
 - Your own installation of the game, with this exact executable:
@@ -187,10 +188,22 @@ tools/gen_v2.sh "$EXE"
 ./run.sh             # windowed
 ./run.sh 1080p       # 1920x1080, widescreen-corrected
 ./run.sh hd          # HD build
-./pack.sh            # out/NFSU2.app
-./pack.sh --hd       # out/NFSU2 HD.app
+./pack.sh            # out/NFSU2.app: launcher + both engines (Original and HD)
+./pack.sh --zip      # also out/NFSU2.zip for a release
+./pack.sh --embed    # out/personal/NFSU2.app with your game inside (do not share)
 ```
 
+The app opens a small launcher window first (`launcher/`, built by `pack.sh`
+with `swiftc`): it finds and checks `SPEED2.EXE`, offers Original or HD graphics
+and full screen, opens the saves and logs folders, and **Make Copy…** builds a
+portable app with the game files inside (APFS clones, seconds on the same disk),
+so nobody needs `pack.sh --embed` or a terminal for that. Untick "Show this
+window when the app opens" to go straight into the game (hold Option to get the
+window back). `NFSU2_SKIP_LAUNCHER=1` / `NFSU2_ENGINE=original|hd` do the same
+from scripts.
+
+![Launcher window](screenshots/selected/launcher.png)
+
 `run.sh` documents the environment switches; most are diagnostics.
 
 While playing, **Cmd+Shift+D** writes the next frame as a PNG plus the full
@@ -204,8 +217,9 @@ a report.
 **Can I play Need for Speed: Underground 2 on a Mac?**
 Yes, on an Apple Silicon Mac (M1 or later) with your own copy of the PC game.
 Download `NFSU2.zip` from the [Releases page](https://github.com/TalhaMudo/NFSU2Recomp/releases/latest), or build the port as
-described above (`./pack.sh` produces a double-clickable `NFSU2.app`). Menus,
-races, career saves and sound work.
+described above (`./pack.sh` produces a double-clickable `NFSU2.app`). Open it,
+choose the game folder once, click Play. Menus, races, career saves and sound
+work.
 
 **Do I need Wine, CrossOver, Whisky, Parallels or a virtual machine?**
 No. The game's code is recompiled to native ARM64 and runs directly on macOS.
@@ -217,12 +231,21 @@ against 10–15 fps under Wine 11.18 with Rosetta 2, and 119 fps against 45 fps
 in the 3D menus. Method and raw numbers are in `WINE_COMPARISON.md`.
 
 **Is there a ready-made download?**
-Yes: the [Releases page](https://github.com/TalhaMudo/NFSU2Recomp/releases/latest) has `NFSU2.zip` (standard build) and
-`NFSU2.HD.zip` (MSAA, ray-traced reflections). Neither contains game files; on
-first launch the app asks for the folder that holds your own `SPEED2.EXE`. The
-app is not notarized, so after moving it to Applications run once:
+Yes: the [Releases page](https://github.com/TalhaMudo/NFSU2Recomp/releases/latest) has `NFSU2.zip`. The app holds both
+graphics modes, Original and HD (MSAA, ray-traced reflections), chosen in its
+window; older releases had a separate `NFSU2.HD.zip`. It contains no game files:
+the window asks for the folder that holds your own `SPEED2.EXE`.
+The app is not notarized, so macOS blocks the first start: open System Settings ›
+Privacy & Security and click **Open Anyway** (on macOS 14 and older: right-click
+the app › Open). If macOS says the app is damaged, run once in Terminal:
 `xattr -dr com.apple.quarantine /Applications/NFSU2.app`
 
+**Can I carry the game to another Mac in one piece?**
+Yes. In the app's window, **Make Copy…** creates "NFSU2 Portable.app" with the
+game files inside (about 1.4 GB). It runs on its own; saves stay in
+`~/Library/Application Support/NFSU2 Saves` on each Mac. It contains the game,
+so keep it for yourself.
+
 **Which version of the game does it need?**
 The Windows PC version, with the exact `SPEED2.EXE` listed under
 [Requirements](#requirements). Other builds, including the console versions,
 
@@ -0,0 +1,136 @@
+// Finding and checking the game files, and the small settings the launcher owns.
+//
+// The search order is the same as the engine's (runtime/bundle.m, app_find_game):
+// data inside the bundle, the folder chosen before, next to the app, its parent
+// folder, a few usual places in the home folder.  The engine gets the exact
+// SPEED2.EXE the launcher checked through NFSU2_DATA.
+import Foundation
+import CryptoKit
+
+enum SupportedExe {
+    static let size: UInt64 = 4_788_224
+    static let sha256 = "8f6a9ae2c4cfa01181d2fd755d99c6f4b7103f60273908ea1de1e719dfe2a297"
+    static let names = ["SPEED2.EXE", "speed2.exe", "Speed2.exe"]
+}
+
+struct GameLocation: Equatable {
+    let exe: URL
+    let embedded: Bool
+    var folder: URL { exe.deletingLastPathComponent() }
+}
+
+enum GameState: Equatable {
+    case searching
+    case notFound
+    case ready(GameLocation)
+    case unsupported(GameLocation, UInt64)    // exe size in bytes
+}
+
+enum Paths {
+    static var home: URL { FileManager.default.homeDirectoryForCurrentUser }
+    static var bundle: URL { Bundle.main.bundleURL }
+    static var resources: URL { bundle.appendingPathComponent("Contents/Resources") }
+    static var embeddedGame: URL { resources.appendingPathComponent("Game") }
+    static var macOS: URL { bundle.appendingPathComponent("Contents/MacOS") }
+    static var saves: URL { home.appendingPathComponent("Library/Application Support/NFSU2 Saves") }
+    static var logs: URL { home.appendingPathComponent("Library/Logs/NFSU2") }
+    static var registry: URL { home.appendingPathComponent(".nfsu2_registry") }
+}
+
+enum Prefs {
+    // Shared with the engine (same bundle id, same defaults domain).
+    static let gameFolder = "OyunDizini"          // name kept for existing installs
+    static let fullscreen = "NFSUFullScreen"
+    // Launcher only.
+    static let engine = "LauncherEngine"           // "original" | "hd"
+    static let showAtStartup = "LauncherShowAtStartup"
+}
+
+enum Locator {
+    static func exeIn(_ dir: URL) -> URL? {
+        for n in SupportedExe.names {
+            let u = dir.appendingPathComponent(n)
+            var isDir: ObjCBool = false
+            if FileManager.default.fileExists(atPath: u.path, isDirectory: &isDir), !isDir.boolValue { return u }
+        }
+        return nil
+    }
+
+    /// The folder itself or up to two levels below it ("...Clean Edition/Need for Speed Underground 2").
+    static func find(under dir: URL, depth: Int = 2) -> URL? {
+        if let e = exeIn(dir) { return e }
+        guard depth > 0,
+              let kids = try? FileManager.default.contentsOfDirectory(
+                at: dir, includingPropertiesForKeys: [.isDirectoryKey, .isPackageKey],
+                options: [.skipsHiddenFiles]) else { return nil }
+        for k in kids.sorted(by: { $0.lastPathComponent < $1.lastPathComponent }) {
+            let v = try? k.resourceValues(forKeys: [.isDirectoryKey, .isPackageKey])
+            guard v?.isDirectory == true, v?.isPackage != true else { continue }
+            if let e = find(under: k, depth: depth - 1) { return e }
+        }
+        return nil
+    }
+
+    static func locate() -> GameLocation? {
+        if let env = ProcessInfo.processInfo.environment["NFSU2_DATA"], !env.isEmpty {
+            let u = URL(fileURLWithPath: env)
+            var isDir: ObjCBool = false
+            if FileManager.default.fileExists(atPath: u.path, isDirectory: &isDir) {
+                if !isDir.boolValue { return GameLocation(exe: u, embedded: false) }
+                if let e = find(under: u) { return GameLocation(exe: e, embedded: false) }
+            }
+        }
+        if let e = find(under: Paths.embeddedGame) { return GameLocation(exe: e, embedded: true) }
+        if let saved = UserDefaults.standard.string(forKey: Prefs.gameFolder),
+           let e = find(under: URL(fileURLWithPath: saved)) { return GameLocation(exe: e, embedded: false) }
+        let besideApp = Paths.bundle.deletingLastPathComponent()
+        for d in [besideApp, besideApp.deletingLastPathComponent()] {
+            if let e = find(under: d) { return GameLocation(exe: e, embedded: false) }
+        }
+        for rel in ["Library/Application Support/NFSU2",
+                    "Documents/Need for Speed Underground 2",
+                    "Downloads/Need for Speed Underground 2",
+                    "Desktop/Need for Speed Underground 2"] {
+            if let e = find(under: Paths.home.appendingPathComponent(rel)) {
+                return GameLocation(exe: e, embedded: false)
+            }
+        }
+        return nil
+    }
+
+    static func fileSize(_ u: URL) -> UInt64 {
+        ((try? FileManager.default.attributesOfItem(atPath: u.path))?[.size] as? NSNumber)?.uint64Value ?? 0
+    }
+
+    /// true when this is the one SPEED2.EXE the port was built from.
+    static func isSupported(_ exe: URL) -> Bool {
+        if ProcessInfo.processInfo.environment["NFSU2_ANY_EXE"] == "1" { return true }
+        guard fileSize(exe) == SupportedExe.size,
+              let data = try? Data(contentsOf: exe, options: .mappedIfSafe) else { return false }
+        let hex = SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined()
+        return hex == SupportedExe.sha256
+    }
+
+    static func check(_ loc: GameLocation) -> GameState {
+        isSupported(loc.exe) ? .ready(loc) : .unsupported(loc, fileSize(loc.exe))
+    }
+}
+
+enum Registry {
+    /// Forget the saved graphics settings so the game picks settings for this Mac
+    /// again on its next start (its own first-run detection).  Saves untouched.
+    static func resetGraphics() throws {
+        let u = Paths.registry
+        guard let text = try? String(contentsOf: u, encoding: .utf8) else { return }
+        let kept = text.split(separator: "\n", omittingEmptySubsequences: true).filter { line in
+            !(line.hasPrefix("d g_") || line.hasPrefix("s g_") || line.hasPrefix("d NotFirstTime="))
+        }
+        try (kept.joined(separator: "\n") + "\n").write(to: u, atomically: true, encoding: .utf8)
+    }
+}
+
+func formatBytes(_ n: Int64) -> String {
+    let f = ByteCountFormatter()
+    f.countStyle = .file
+    return f.string(fromByteCount: n)
+}