Skip to content

Free fork of NotProton: Windows Steam games in Mac Steam, on CodeWeavers' Wine and Apple's Game Porting Toolkit

Merge remote-tracking branch 'origin/main'

Leon Seemannd9d0cf08a8eb
diff --cc README.md
index 957f64e,323fb5c..f3ffaf6
--- a/README.md
+++ b/README.md
@@@ -5,35 -5,10 +5,35 @@@ NotProton enables the Steam Play experi
This is done by forcibly enabling the Steam Play functionality in macOS Steam (which is
present and inert) as well as by porting some components of Valve's Proton to macOS.
- This tool is intended to be used with Steam Client 1788652215 or 1790121765 and **CrossOver Preview
- 20261006 or 2026082**. Both the FEX build and the Rosetta build are supported. The Rosetta build is
- the recommended version, as the FEX one is in an early state.
+ This tool is intended to be used with Steam Client 1788652215 or 1790121765 and **CrossOver 26.3 or CrossOver Preview
+ 20261006 or 2026082**. Both the FEX and the Rosetta versions are supported. I recommend using the FEX version of the
+ Preview 20261006, as it includes both the FEX version as well as the Rosetta one.
+## Free Wine engine (no CrossOver needed)
+
+NotProton can also run entirely on free software. Under Compatibility Tool, **Download & Set Up**
+fetches the WineHQ 11.15 macOS build from [Gcenx/macOS_Wine_builds](https://github.com/Gcenx/macOS_Wine_builds)
+(hash pinned), unpacks it into `~/Library/Application Support/notproton/engines/` and sets the
+compatibility tool up from it exactly like a CrossOver copy. No CrossOver license is involved; the
+license check is skipped only for loaders whose hash pins the free build.
+
+11.15 is chosen because it is the Wine the bridge components (`lsteamclient`, `steam.exe`) are built
+against. Differences from CrossOver to be aware of:
+
+- It is an x86_64 build and runs under Rosetta 2, like the Rosetta build of CrossOver.
+- Direct3D 10/11 goes through [DXMT](https://github.com/3Shain/dxmt) (MIT), downloaded and pinned
+ alongside Wine, which translates straight to Metal. Wine's own wined3d cannot reach feature level 11
+ on macOS OpenGL. D3DMetal is Apple's and only works with CrossOver's Wine, so it is not used.
+- DXMT needs macdrv functions upstream Wine hides; NotProton ships a rebuilt `winemac.so`
+ that exports them (see `winemac-patch/`).
+- D3D 12 has no fast path; vkd3d over the bundled MoltenVK is limited.
+- WineHQ has no msync/esync, so CPU-heavy games can run slower than under CrossOver or Sikarugir.
+- The graphics backend options in the Steam panel have no effect on this engine.
+
+To support another WineHQ build, run `ntdll-patch/resolve.py` against its Wine tree, build the
+payloads with `ntdll-patch/build.sh` / `build32.sh`, and add the hashes to `SupportedRunners`,
+`NtdllPatcher.byBuild` and `FreeEngine`.
+
The macOS app itself is located in the ```app``` folder. The core logic is in ```dylib```.
```lsteamclient``` is a macOS port of Valve's lsteamclient. ```steam-shim```is a port of Valve's
steam-helper from Proton 9. ntdll-patch patches the copy of CrossOver that the app
diff --cc app/Package.swift
index 2b2e4b2,bdbadb5..55c8ff1
--- a/app/Package.swift
+++ b/app/Package.swift
@@@ -30,13 -31,13 +31,16 @@@ let package = Package
.copy("Resources/detour32.bin"),
.copy("Resources/detour32-fex.bin"),
.copy("Resources/detour64-fex.bin"),
+ .copy("Resources/detour2-cx26.bin"),
+ .copy("Resources/detour32-cx26.bin"),
.copy("Resources/detour2-41069.bin"),
.copy("Resources/detour32-41069.bin"),
+ .copy("Resources/detour2-fex-41069.bin"),
.copy("Resources/detour32-fex-41069.bin"),
.copy("Resources/detour64-fex-41069.bin"),
+ .copy("Resources/detour2-winehq-11.15.bin"),
+ .copy("Resources/detour32-winehq-11.15.bin"),
+ .copy("Resources/winemac-winehq-11.15.so"),
],
swiftSettings: [.swiftLanguageMode(.v6)]
),
diff --cc app/Sources/NotProtonApp/Model/CrossOverSource.swift
index 8ee452a,ea4b67c..4cca3c4
--- a/app/Sources/NotProtonApp/Model/CrossOverSource.swift
+++ b/app/Sources/NotProtonApp/Model/CrossOverSource.swift
@@@ -40,16 -35,38 +40,40 @@@ enum CrossOverSource
SupportPaths.home.appending(path: "Applications", directoryHint: .isDirectory),
]
+ static var engineRoot: URL { SupportPaths.engines }
+
- private static let manualKey = "manualCrossOverPath"
+ private static let manualKey = "manualCrossOverPaths"
+ // 1.0/1.0.1 kept a single chosen copy under this key.
+ private static let legacyManualKey = "manualCrossOverPath"
+
+ static func manualBundles(_ defaults: UserDefaults = .standard) -> [URL] {
+ let paths = defaults.stringArray(forKey: manualKey)
+ ?? defaults.string(forKey: legacyManualKey).map { [$0] } ?? []
+ return paths.filter { !$0.isEmpty }.map { URL(filePath: $0, directoryHint: .isDirectory) }
+ }
- static var manualBundle: URL? {
- get {
- guard let path = UserDefaults.standard.string(forKey: manualKey), !path.isEmpty else { return nil }
- return URL(filePath: path, directoryHint: .isDirectory)
- }
- set { UserDefaults.standard.set(newValue?.path(percentEncoded: false), forKey: manualKey) }
+ static func setManualBundles(_ bundles: [URL], _ defaults: UserDefaults = .standard) {
+ defaults.set(bundles.map { $0.path(percentEncoded: false) }, forKey: manualKey)
+ defaults.removeObject(forKey: legacyManualKey)
+ }
+
+ static func addManualBundle(_ bundle: URL, _ defaults: UserDefaults = .standard) {
+ let current = manualBundles(defaults)
+ guard !current.contains(where: { same($0, bundle) }) else { return }
+ setManualBundles(current + [bundle], defaults)
+ }
+
+ static func removeManualBundle(_ bundle: URL, _ defaults: UserDefaults = .standard) {
+ setManualBundles(manualBundles(defaults).filter { !same($0, bundle) }, defaults)
+ }
+
+ static func isSearched(_ bundle: URL) -> Bool {
+ let parent = bundle.standardizedFileURL.deletingLastPathComponent()
+ return searchRoots.contains { same($0, parent) }
+ }
+
+ static func same(_ a: URL, _ b: URL) -> Bool {
+ a.standardizedFileURL.path(percentEncoded: false) == b.standardizedFileURL.path(percentEncoded: false)
}
// A CrossOver bundle without this directory is bad!
diff --cc app/Sources/NotProtonApp/Model/SupportedRunner.swift
index 60f6e94,2baa450..c3f796a
--- a/app/Sources/NotProtonApp/Model/SupportedRunner.swift
+++ b/app/Sources/NotProtonApp/Model/SupportedRunner.swift
@@@ -28,20 -28,133 +28,137 @@@ struct RunnerBuild: Sendable, Equatable
let cleanNtdll: [WineArch: String]
let patchedNtdll: [WineArch: String]
+ var tools: [CompatTool] = []
+
+ // A free WineHQ engine NotProton downloads itself rather than a CrossOver
+ // install. It has no license to check.
+ var isFree = false
+
+ var rebuilds: [RunnerRebuild] = []
+
var id: String { flavor.map { "\(bundleVersion)-\($0)" } ?? bundleVersion }
+ func matching(loaderSHA256 hash: String) -> RunnerBuild? {
+ if hash == loaderSHA256 { return self }
+ guard let rebuild = rebuilds.first(where: { $0.loaderSHA256 == hash }) else { return nil }
+ return RunnerBuild(
+ bundleVersion: bundleVersion, releaseVersion: releaseVersion, flavor: flavor,
+ loaderSHA256: rebuild.loaderSHA256, cleanNtdll: rebuild.cleanNtdll,
- patchedNtdll: rebuild.patchedNtdll, tools: tools, rebuilds: rebuilds
++ patchedNtdll: rebuild.patchedNtdll, tools: tools, isFree: isFree, rebuilds: rebuilds
+ )
+ }
+
var flavorName: String { flavor?.uppercased() ?? "Rosetta" }
var displayVersion: String { "\(releaseVersion) \(flavorName)" }
}
+ // The version of CrossOver offered in China has different hashes but is identical in the ways that matter
+ struct RunnerRebuild: Sendable, Equatable {
+ let loaderSHA256: String
+ let cleanNtdll: [WineArch: String]
+ let patchedNtdll: [WineArch: String]
+ }
+
+ struct CompatTool: Sendable, Hashable, Identifiable {
+ enum Flavor: String, Sendable, CaseIterable {
+ case rosetta
+ case fex
+
+ var name: String { self == .fex ? "FEX" : "Rosetta" }
+ var unixDir: String { self == .fex ? "aarch64-unix" : "x86_64-unix" }
+ }
+
+ let name: String
+ let flavor: Flavor
+ let display: String
+
+ var id: String { name }
+
+ var prefixArch: PrefixArch { flavor == .fex ? .arm64 : .x86_64 }
+ }
+
+ struct InstalledTool: Sendable, Hashable, Identifiable {
+ let tool: CompatTool
+ let build: String
+
+ var id: String { tool.name }
+ var name: String { tool.name }
+ var display: String { tool.display }
+ }
+
enum SupportedRunners {
+ // First entry is what windows-only games get when Steam has no mapping.
+ static let toolPreference = [
+ legacyToolName, "notproton-fex", "notproton-fex-rosetta", "notproton-preview",
- "notproton-fex-41069", "notproton-fex-rosetta-41069", "notproton-preview-41069", "notproton-26.3",
++ "notproton-fex-41069", "notproton-fex-rosetta-41069", "notproton-preview-41069", "notproton-26.3", "notproton-winehq",
+ ]
+
+ static let legacyToolName = "notproton"
+
+ // The only builds that can own the 'notproton' tool name.
+ static let legacyHolders = ["27.0.0.40921-fex", "27.0.0.40921", "27.0.0.41069-fex", "27.0.0.41069"]
+
+ enum LegacyHolder: Equatable, Sendable {
+ case build(String)
+ case nobody
+ }
+
+ static func tools(for builds: [RunnerBuild], legacy: LegacyHolder = .nobody) -> [InstalledTool] {
+ let installed = Set(builds.map(\.id))
+ let holder: String? = switch legacy {
+ case .build(let id): id
+ case .nobody: nil
+ }
+ let served = all.filter { installed.contains($0.id) }.flatMap { build in
+ build.tools.enumerated().map { index, tool in
+ let name = build.id == holder && index == 0 ? legacyToolName : tool.name
+ return InstalledTool(
+ tool: CompatTool(name: name, flavor: tool.flavor, display: tool.display), build: build.id
+ )
+ }
+ }
+ func rank(_ tool: InstalledTool) -> Int {
+ toolPreference.firstIndex(of: tool.name) ?? toolPreference.count
+ }
+ return served.enumerated()
+ .sorted { (rank($0.element), $0.offset) < (rank($1.element), $1.offset) }
+ .map(\.element)
+ }
+
static let all: [RunnerBuild] = [
+ RunnerBuild(
+ bundleVersion: "26.3.0.39832",
+ releaseVersion: "26.3",
+ flavor: nil,
+ loaderSHA256: "b5edb0444b5b25ba0aa5091be1cba11680130895c338cc8044101bce98802a63",
+ cleanNtdll: [
+ .x86_64Windows: "6dff64c00793ce92124f1316985c63783f539f26b392975c70f57637458d2387",
+ .i386Windows: "2c60ee6b00dd13b7f6cb11017778a041ba6a321eaea194f1fa0dca7eab8403e2",
+ ],
+ patchedNtdll: [
+ .x86_64Windows: "c0e21a9a5250f0a97c08d3c3e1798566255387213e2553b1e555264fb9ded97e",
+ .i386Windows: "e641d7b2e81ee13877823494679ba2d87e0d61b8a87e8a1ce92b4fe73631ae74",
+ ],
+ tools: [
+ CompatTool(name: "notproton-26.3", flavor: .rosetta, display: "CrossOver 26.3"),
+ ],
+ rebuilds: [
+ // crossoverchina.com
+ RunnerRebuild(
+ loaderSHA256: "35aeb1a75a48f3b053dbf2395deac33c530a0b0b7db0bc6357362348af9514ce",
+ cleanNtdll: [
+ .x86_64Windows: "1c4799bb3769ba1392c2298e4904ce0b080f040940b2a273f4eaa0906b231a93",
+ .i386Windows: "21e7d0a6d6868f1853489f5a9798e706509a20a65ee370f50b37ab7b1cdcaae3",
+ ],
+ patchedNtdll: [
+ .x86_64Windows: "3725117cc103acd9d2713535e41733563f340e27604e1abdea5afbdc2c2be65a",
+ .i386Windows: "6d9ef05089fea07d1f4cbebe27df1f9a92dbc8eb245033db9f5e40a943175d5b",
+ ]
+ ),
+ ]
+ ),
RunnerBuild(
bundleVersion: "27.0.0.40921",
releaseVersion: "20260821",
@@@ -94,25 -220,15 +224,33 @@@
.aarch64Windows: "77ca83b2e1a3a1242f9d2d8868328262b2bcfc3f59bacf8b9389ea7e797ea852",
],
patchedNtdll: [
+ .x86_64Windows: "7548abd874656f6a6455e7fac659020ed755d92f4e1929a33097bbde964699f5",
.i386Windows: "e16b0199db721a08201b1512476b9eff255624d2faf3696fa57ff74b1a54be5c",
- .aarch64Windows: "89e4c9e7f0a0a60462c0231ec393168f8bdb04bc8ea1dc22211f25bf3ff2c6b3",
+ .aarch64Windows: "7623c0b33350f511b431d39c7ec0c0d4f5def4183acef0eee5d4a5c694898956",
+ ],
+ tools: [
+ CompatTool(name: "notproton-fex-41069", flavor: .fex, display: "CrossOver 2026 10 06-ARM64 - FEX"),
+ CompatTool(name: "notproton-fex-rosetta-41069", flavor: .rosetta, display: "CrossOver 2026 10 06-ARM64 - Rosetta"),
]
),
+ RunnerBuild(
+ bundleVersion: "winehq-11.15",
+ releaseVersion: "WineHQ 11.15",
+ flavor: nil,
+ loaderSHA256: "8aa25e55f28a0634a7df04c02dd719d4bc20de645cf42b9ba7d0e3b7d8f66a80",
+ cleanNtdll: [
+ .x86_64Windows: "682181234a55f5b7eed5b2ffa691fbdef1b488734337ef67ea7b5ce17adf43a2",
+ .i386Windows: "49396e7ad804a5345b1b968d02fdb6697ddbb7428e61e20e62806c50c37589d1",
+ ],
+ patchedNtdll: [
+ .x86_64Windows: "08a825e8236e79c909fae3934ca5e8a195a344d06f8affb6e13cdf1bd9ffa783",
+ .i386Windows: "88f9a1d16dd7127100eab902156390ec2a5ec67770cfddd3fd3f1237c9965309",
+ ],
++ tools: [
++ CompatTool(name: "notproton-winehq", flavor: .rosetta, display: "WineHQ 11.15 - Rosetta"),
++ ],
+ isFree: true
+ ),
]
static func build(loaderSHA256 hash: String) -> RunnerBuild? {
diff --cc app/Sources/NotProtonApp/SystemStatus.swift
index 433297b,a047579..cd65539
--- a/app/Sources/NotProtonApp/SystemStatus.swift
+++ b/app/Sources/NotProtonApp/SystemStatus.swift
@@@ -353,25 -361,12 +361,32 @@@ final class SystemStatus
}
}
+ var freeEngineInstalled: Bool {
+ snapshot?.crossOver.contains { $0.isFree && FreeEngine.hasRenderer(root: $0.crossOverRoot) } ?? false
+ }
+
+ // Downloads the free WineHQ engine and sets the compatibility tool up from it,
+ // so no CrossOver install or license is needed.
+ func installFreeEngine() async {
- guard isIdle else { return }
++ guard canInstall else { return }
+ await perform(from: FreeEngine.step) { progress in
++ let lock = try DeploymentContent.acquireInstallationLock(for: SupportPaths.Steam.app)
++ defer { close(lock) }
++ try await requireInstallableContent()
+ let install = try await FreeEngine.install { progress($0.label) }
+ let result = try await Task.detached(priority: .userInitiated) {
+ try RunnerSetup.run(from: install, replacingExisting: true) { progress($0.label) }
+ }.value
+ return runnerOutcome(result)
+ }
+ }
+
func fetchValveBinaries() async {
+ guard canInstall else { return }
await perform(from: ValveFetcher.Phase.verifying.label) { progress in
+ let lock = try DeploymentContent.acquireInstallationLock(for: SupportPaths.Steam.app)
+ defer { close(lock) }
+ try await requireInstallableContent()
let result = try await ValveFetcher.run { progress($0.label) }
return result.wroteNothing ? nil : "Downloaded missing components."
}
diff --cc app/Sources/NotProtonApp/Views/StatusView.swift
index 50937c0,ff800d6..ae4fc4d
--- a/app/Sources/NotProtonApp/Views/StatusView.swift
+++ b/app/Sources/NotProtonApp/Views/StatusView.swift
@@@ -424,85 -527,70 +527,88 @@@ struct StatusView: View
}
@ViewBuilder
- private func crossOverRows(_ snapshot: StatusSnapshot) -> some View {
- let installs = snapshot.crossOver.filter(\.isUsable)
- if !installs.isEmpty {
- ForEach(installs) { install in
- if case .supported(let build) = install.support {
- StatusRow(
- title: install.name,
- value: "Build \(build.displayVersion)",
- tone: snapshot.crossOverLicense[install.id]?.licensed == true ? .ok : .warning,
- detail: install.bundle.path(percentEncoded: false),
- action: installs.count > 1
- ? setUpAction(for: install, build: build, snapshot: snapshot)
- : crossOverAction()
- )
- }
- }
- } else {
+ private func crossOverSection(_ snapshot: StatusSnapshot) -> some View {
+ let rows = status.crossOverRows
+ if rows.isEmpty {
StatusRow(
- title: "CrossOver",
- value: "Not found. Supported: \(SupportedRunners.versionList).",
+ title: "Wine Engine",
+ value: "None found. Download the free WineHQ engine, or use CrossOver "
+ + "(\(SupportedRunners.versionList)).",
- tone: .bad,
- action: crossOverAction()
+ tone: .bad
)
}
+ if !status.freeEngineInstalled {
- let outdated = installs.contains(where: \.isFree)
++ let outdated = snapshot.crossOver.contains(where: \.isFree)
+ StatusRow(
+ title: "Free Wine Engine",
+ value: outdated
+ ? "Needs \(FreeEngine.current.renderer.name) for fast Direct3D 11."
+ : "\(FreeEngine.current.bundleName.replacingOccurrences(of: ".app", with: "")) with \(FreeEngine.current.renderer.name), "
+ + "no CrossOver license needed.",
+ tone: outdated ? .warning : .neutral,
+ action: StatusAction(
+ label: outdated ? "Update & Set Up" : "Download & Set Up",
- isProminent: installs.isEmpty,
++ isProminent: rows.isEmpty,
+ help: "Download WineHQ and set the compatibility tool up from it.",
- isEnabled: status.isIdle
++ isEnabled: status.canInstall
+ ) { Task { await status.installFreeEngine() } }
+ )
+ }
+ let tools = SupportedRunners.tools(for: snapshot.installedRunners)
+ ForEach(rows) { row in
+ StatusRow(
+ title: row.title,
+ value: crossOverValue(row),
+ tone: crossOverTone(row),
+ detail: crossOverDetail(row, tools: tools),
+ trailing: row.copy == .ready ? buildSize(row.buildID) : nil,
+ action: crossOverAction(row, prominent: snapshot.runner == .none),
+ menu: crossOverMenu(row)
+ )
+ .background {
+ RoundedRectangle(cornerRadius: 6)
+ .fill(Color.accentColor.opacity(0.2))
+ .padding(-6)
+ .opacity(status.highlightedRow == row.id ? 1 : 0)
+ }
+ .animation(.easeInOut(duration: 0.3), value: status.highlightedRow == row.id)
+ .id(row.id)
+ }
+ if case .ready = snapshot.runner, !snapshot.payload.missing(origin: .patched).isEmpty {
+ StatusRow(
+ title: "Compatibility Tool",
+ value: "Patched components are missing.",
+ tone: .warning,
+ action: StatusAction(
+ label: "Repair",
+ isProminent: true,
+ help: "Set up the compatibility tool again.",
+ isEnabled: status.isIdle && status.setupSource != nil
+ ) { Task { await status.requestCompatibilityTool() } }
+ )
+ }
}
- private func crossOverAction(chooseLabel: String = "Choose\u{2026}") -> StatusAction {
- if status.chosenCrossOver != nil {
- return StatusAction(
- label: "Use Search",
- help: "Use the default Wine engine search.",
- isEnabled: status.isIdle
- ) { Task { await status.clearCrossOverChoice() } }
- }
- return StatusAction(
- label: chooseLabel,
- help: "Pick a CrossOver install or Wine engine.",
- isEnabled: status.isIdle
- ) { Task { await status.chooseCrossOver() } }
- }
-
- @ViewBuilder
- private var crossOverLink: some View {
- let action = crossOverAction(chooseLabel: "Choose Another Copy\u{2026}")
- Button(action.label, action: action.perform)
- .buttonStyle(.link)
- .disabled(!action.isEnabled)
- .help(action.help ?? "")
+ private func crossOverValue(_ row: CrossOverRow) -> String {
+ if let version = row.unsupportedVersion {
+ return "Version \(version) not supported (supported: \(SupportedRunners.versionList))"
+ }
+ let build = "Build \(SupportedRunners.displayVersion(forID: row.buildID))"
+ switch row.copy {
+ case .ready: return build
+ case .none: return build + (row.licensed == false ? ", not set up or activated" : ", not set up")
+ case .unpatched: return build + ", not patched"
+ case .damaged: return build + ", copy damaged"
+ case .unsupported: return build + ", not supported"
+ }
}
- private func setUpAction(
- for install: CrossOverInstall, build: RunnerBuild, snapshot: StatusSnapshot
- ) -> StatusAction? {
- guard !snapshot.installedRunners.contains(build) else { return nil }
- return StatusAction(
- label: "Set Up",
- isProminent: snapshot.runner == .none,
- help: "Set up the compatibility tool from \(install.name).",
- isEnabled: status.isIdle
- ) {
- Task { await status.requestCompatibilityTool(from: install) }
+ private func crossOverTone(_ row: CrossOverRow) -> StatusTone {
+ if row.unsupportedVersion != nil { return .neutral }
+ switch row.copy {
+ case .none: return row.licensed == false ? .warning : .neutral
+ case .ready: return .ok
+ case .unpatched, .damaged, .unsupported: return .warning
}
}
diff --cc app/Tests/NotProtonAppTests/NtdllPatcherTests.swift
index 69da35e,2d826c2..816a28a
--- a/app/Tests/NotProtonAppTests/NtdllPatcherTests.swift
+++ b/app/Tests/NotProtonAppTests/NtdllPatcherTests.swift
@@@ -324,13 -324,10 +324,14 @@@ struct NtdllPatcherTests
// The point of the port: the same input has to come out as the bytes apply.py and
// apply32.py produced, which SupportedRunners records. Needs an unpatched CrossOver.
- @Test("Patching the unpatched ntdll reproduces the recorded hashes",
- arguments: ["CrossOver Preview", "CrossOver"])
- func realNtdllReproducesRecordedHashes(app: String) throws {
- let root = URL(filePath: "/Applications/\(app).app/Contents/SharedSupport/CrossOver")
+ @Test("Patching the unpatched ntdll reproduces the recorded hashes", arguments: [
+ URL(filePath: "/Applications/CrossOver Preview.app/Contents/SharedSupport/CrossOver"),
++ URL(filePath: "/Applications/CrossOver.app/Contents/SharedSupport/CrossOver"),
+ // The free engine, once NotProton or NOTPROTON_WINEHQ_ROOT has provided one.
+ ProcessInfo.processInfo.environment["NOTPROTON_WINEHQ_ROOT"].map { URL(filePath: $0) }
+ ?? SupportPaths.crossOverRoot(inBundle: FreeEngine.bundle()),
+ ])
+ func realNtdllReproducesRecordedHashes(root: URL) throws {
guard FileManager.default.fileExists(atPath: root.path(percentEncoded: false)),
let installed = Digest.sha256IfPresent(CrossOverSource.unixLoader(inRoot: root)),
let build = SupportedRunners.build(loaderSHA256: installed)
diff --cc dylib/feats/compat_run.sh
index be3993e,eed71af..dc877f3
--- a/dylib/feats/compat_run.sh
+++ b/dylib/feats/compat_run.sh
@@@ -423,11 -1065,14 +1085,15 @@@ if [ -d "$bridge_src" ] && [ -n "$WINEP
esac
done
verify_runner
- install_lsteamclient_trigger
+ if ! install_lsteamclient_trigger; then
+ show_alert "Steam files could not be copied" "NotProton could not copy a file into this game's prefix. Open this prefix's notproton-run.log for details."
+ exit 1
+ fi
install_legacy_steam_dll
+ install_runner_builtins
export WINEDLLPATH="$prefix_steam:$WINEDLLPATH"
- export WINEDLLOVERRIDES="steamclient=n;steamclient64=n;lsteamclient=b"
+ # If the same DLL appears twice in WINEDLLOVERRIDES, the last entry wins.
+ export WINEDLLOVERRIDES="${WINEDLLOVERRIDES:+$WINEDLLOVERRIDES;}steamclient=n;steamclient64=n;lsteamclient=b"
native_client="$STEAM_COMPAT_CLIENT_INSTALL_PATH"
if [ -z "$native_client" ]; then
native_client="$HOME/Library/Application Support/Steam/Steam.AppBundle/Steam/Contents/MacOS"