Skip to content

Run Windows games on Apple Silicon — free, open source, with an open compatibility database that tells you what actually works.

Engine arm64-wine11.18-r5 for Microsoft Flight Simulator 2024 (preview line), and Play offers it to players on r3 (#388)

Gauthier Piarrette210c04f5ec49
diff --git a/Sources/HighballApp/AppState.swift b/Sources/HighballApp/AppState.swift
index fa6aa38..4ea76e4 100644
--- a/Sources/HighballApp/AppState.swift
+++ b/Sources/HighballApp/AppState.swift
@@ -440,9 +440,11 @@ final class AppState {
var bottle = found
// A recipe pinned to a preview engine this Mac does not see yet: before 0.10.19 Play launched the game here
// as if the recipe did not exist, which for Microsoft Flight Simulator 2024 was a Rosetta engine it cannot
- // start on. An environment already on that engine counts as the player's choice; any other asks first.
+ // start on. An environment already on that engine counts as the player's choice, and so does one on an
+ // earlier revision of its line (the move is offered just below); any other asks first.
if fixRecipe(for: item) == nil, let offer = previewOffer(for: item) {
- if let current = engine(for: bottle), EngineManifest.satisfies(current: current.manifest, wanted: offer.manifest) {
+ if let current = engine(for: bottle), EngineManifest.satisfies(current: current.manifest, wanted: offer.manifest)
+ || EngineChannels.runsLine(current: current.manifest, of: offer.manifest) {
Self.optInPreview(offer.manifest.id)
play(item, renderer: renderer, windowsBuild: windowsBuild)
} else {
@@ -450,6 +452,17 @@ final class AppState {
}
return
}
+ // An environment on an earlier revision of the preview line its game's recipe now pins (Microsoft Flight
+ // Simulator 2024 set up on r3 when its recipe moved to r5, 2026-10-19). The engine ask further down comes only
+ // before a recipe is applied, so nothing else would offer the revision the database verifies now. Asked once
+ // per environment and revision; the environment's Engine setting can move it any time after.
+ if let recipe = fixRecipe(for: item), !recipe.isOptIn, bottle.settings.recipes.contains(recipe.id),
+ let engine = engine(for: bottle),
+ let wanted = recipe.previewRevisionToOffer(current: engine.manifest, known: Self.knownManifests),
+ Self.firstPreviewMoveAsk(bottle: bottle.name, engine: wanted.id) {
+ pendingPreviewMove = (recipe, bottle, engine.manifest, wanted, item, renderer)
+ return
+ }
// A game whose recipe was applied before variables were scoped still has them bottle-wide,
// where every other program inherits them (highball#198). Move them to the game once; the
// launch below then carries them for this game only, and the log says what moved. Then the
@@ -1470,6 +1483,47 @@ final class AppState {
launch(pending.item, in: pending.bottle, renderer: pending.renderer)
}
+ /// An environment on an earlier revision of the preview line its game's recipe pins, asked from Play
+ /// (Recipe.previewRevisionToOffer). `current` is the revision the environment runs.
+ var pendingPreviewMove: (recipe: HighballKit.Recipe, bottle: Bottle, current: EngineManifest, manifest: EngineManifest,
+ item: LibraryItem, renderer: Renderer?)?
+
+ /// The move's way in: the environment moves to the later revision, after a download when it is new, and the done
+ /// row offers Play, which brings the recipe's variables up to date before the launch.
+ func acceptPreviewMove() {
+ guard let pending = pendingPreviewMove else { return }
+ pendingPreviewMove = nil
+ let item = pending.item
+ moveBottle(pending.bottle, toEngineID: pending.manifest.id, done: DoneState(
+ title: L("Engine switched"), ctaTitle: String(format: L("Play %@"), displayTitle(item)),
+ cta: { [weak self] in
+ guard let self else { return }
+ self.refresh()
+ self.play(self.libraryItems.first { $0.id == item.id } ?? item)
+ }))
+ }
+
+ /// The move's way out that keeps playing, on the revision the environment runs. The ask was recorded, so Play
+ /// goes straight on.
+ func playWithoutPreviewMove() {
+ guard let pending = pendingPreviewMove else { return }
+ pendingPreviewMove = nil
+ play(pending.item, renderer: pending.renderer)
+ }
+
+ /// Environments Play offered a later preview revision, as "<environment>\t<engine id>": the ask comes once.
+ static let previewMoveAskedKey = "previewMoveAsked"
+
+ /// True the first time for an environment and revision, and records it.
+ static func firstPreviewMoveAsk(bottle: String, engine: String) -> Bool {
+ let key = "\(bottle)\t\(engine)"
+ var asked = UserDefaults.standard.stringArray(forKey: previewMoveAskedKey) ?? []
+ guard !asked.contains(key) else { return false }
+ asked.append(key)
+ UserDefaults.standard.set(asked, forKey: previewMoveAskedKey)
+ return true
+ }
+
/// Whether the game Play started from `bottle` can come along to a new environment as a clone.
func canCarryGame(_ item: LibraryItem?, from bottle: Bottle) -> Bool {
guard let item, item.source == .steam, let appid = item.steamAppID,
diff --git a/Sources/HighballApp/EngineAsk.swift b/Sources/HighballApp/EngineAsk.swift
index 5cb346b..af2eba0 100644
--- a/Sources/HighballApp/EngineAsk.swift
+++ b/Sources/HighballApp/EngineAsk.swift
@@ -72,6 +72,18 @@ extension GamePageCopy {
return String(format: text, recipe.title, shortEngineName(manifest)) + memoryNote(recipe: recipe, memoryMB: memoryMB)
}
+ /// "r5" for arm64-wine11.18-r5, the id itself when it carries no revision.
+ static func revisionName(_ m: EngineManifest) -> String {
+ EngineManifest.revision(of: m.id).map { "r\($0)" } ?? m.id
+ }
+
+ /// An environment on an earlier revision of the preview line its game's recipe pins (AppState.pendingPreviewMove).
+ static func previewMoveAsk(recipe: HighballKit.Recipe, current: EngineManifest, manifest: EngineManifest, installed: Bool) -> String {
+ let download = installed ? "" : String(format: L(", after a download of about %@"), downloadSize(manifest))
+ return String(format: L("%@ is now verified on %@ of its preview engine, and this environment still runs %@. Moving the environment switches it there%@ and keeps the game and everything else installed. The Windows setup re-runs, which takes a minute or two. Highball asks this once, and the environment's Engine setting can move it later."),
+ recipe.title, revisionName(manifest), revisionName(current), download)
+ }
+
/// One sentence when the recipe names a memory floor this Mac is under, empty otherwise.
static func memoryNote(recipe: HighballKit.Recipe, memoryMB: Int) -> String {
guard let short = recipe.memoryShortfall(memoryMB: memoryMB) else { return "" }
diff --git a/Sources/HighballApp/HighballApp.swift b/Sources/HighballApp/HighballApp.swift
index 7b83097..9b2d1c4 100644
--- a/Sources/HighballApp/HighballApp.swift
+++ b/Sources/HighballApp/HighballApp.swift
@@ -228,6 +228,7 @@ struct ContentView: View {
.engineAsk(state)
.updateAsk(state)
.previewAsk(state)
+ .previewMoveAsk(state)
.uninstallAsk(state)
.rendererTrialAsk(state)
.modesetTrialAsk(state)
@@ -279,14 +280,19 @@ struct ContentView: View {
openSettings()
}
// HB_DEBUG_PLAY="<library item id>" presses Play on that tile, so a script can capture
- // the questions Play asks (the engine ask, highball-db#318).
+ // the questions Play asks (the engine ask, highball-db#318; the preview asks, 0.10.19 and 0.10.20).
+ // HB_DEBUG_ACCEPT=1 then answers a preview ask with "Use the preview engine" and notes the next question.
.task {
guard let id = ProcessInfo.processInfo.environment["HB_DEBUG_PLAY"] else { return }
for _ in 0..<30 {
try? await Task.sleep(for: .seconds(1))
guard let item = state.libraryItems.first(where: { $0.id == id }) else { continue }
state.play(item)
- debugNote(state.paths.logs, "HB_DEBUG_PLAY \(id) in \(item.bottleName ?? "-"): engine ask \(state.pendingEngine.map { "for \($0.manifest.id)" } ?? "not raised")")
+ debugNote(state.paths.logs, "HB_DEBUG_PLAY \(id) in \(item.bottleName ?? "-"): \(debugAsks(state))")
+ if ProcessInfo.processInfo.environment["HB_DEBUG_ACCEPT"] == "1", state.pendingPreview != nil {
+ state.acceptPreview()
+ debugNote(state.paths.logs, "HB_DEBUG_PLAY \(id) after Use the preview engine: \(debugAsks(state))")
+ }
return
}
debugNote(state.paths.logs, "HB_DEBUG_PLAY \(id): no such tile among \(state.libraryItems.count)")
@@ -442,6 +448,19 @@ private extension View {
Text(GamePageCopy.previewAsk(recipe: pending.recipe, manifest: pending.manifest))
}
}
+ /// An environment on an earlier revision of the preview line its game's recipe pins (AppState.pendingPreviewMove).
+ @MainActor func previewMoveAsk(_ state: AppState) -> some View {
+ self.alert(state.pendingPreviewMove.map { String(format: L("A newer preview engine for %@"), $0.recipe.title) } ?? "",
+ isPresented: .init(get: { state.pendingPreviewMove != nil }, set: { if !$0 { state.pendingPreviewMove = nil } }),
+ presenting: state.pendingPreviewMove) { pending in
+ Button(L("Move this environment")) { state.acceptPreviewMove() }
+ Button(String(format: L("Play on %@"), GamePageCopy.revisionName(pending.current))) { state.playWithoutPreviewMove() }
+ Button(L("Not now"), role: .cancel) { state.pendingPreviewMove = nil }
+ } message: { pending in
+ Text(GamePageCopy.previewMoveAsk(recipe: pending.recipe, current: pending.current, manifest: pending.manifest,
+ installed: state.engines.contains { $0.id == pending.manifest.id }))
+ }
+ }
@MainActor func updateAsk(_ state: AppState) -> some View {
self.alert(state.pendingUpdate.map { String(format: L("%@ needs a newer Highball"), $0.recipe.title) } ?? "",
@@ -712,4 +731,11 @@ struct ErrorDetailsSheet: View {
if let h = try? FileHandle(forWritingTo: url) { h.seekToEndOfFile(); h.write(Data(text.utf8)); try? h.close() }
else { try? text.write(to: url, atomically: true, encoding: .utf8) }
}
+
+/// The questions Play left open, for HB_DEBUG_PLAY's note.
+@MainActor func debugAsks(_ state: AppState) -> String {
+ "engine ask \(state.pendingEngine.map { "for \($0.manifest.id)" } ?? "not raised"), "
+ + "preview ask \(state.pendingPreview.map { "for \($0.manifest.id)" } ?? "not raised"), "
+ + "preview move \(state.pendingPreviewMove.map { "from \($0.current.id) to \($0.manifest.id)" } ?? "not raised")"
+}
#endif
diff --git a/Sources/HighballApp/L10n.swift b/Sources/HighballApp/L10n.swift
index e999bf0..e0759ba 100644
--- a/Sources/HighballApp/L10n.swift
+++ b/Sources/HighballApp/L10n.swift
@@ -323,6 +323,10 @@ enum L10n {
"%@ nécessite une configuration unique pour fonctionner comme vérifié.",
"Install the fix first": "Installer d'abord le correctif",
"Play without it": "Jouer sans",
+ "A newer preview engine for %@": "Un moteur en préversion plus récent pour %@",
+ "Play on %@": "Jouer sur %@",
+ "%@ is now verified on %@ of its preview engine, and this environment still runs %@. Moving the environment switches it there%@ and keeps the game and everything else installed. The Windows setup re-runs, which takes a minute or two. Highball asks this once, and the environment's Engine setting can move it later.":
+ "%@ est désormais vérifié sur la révision %@ de son moteur en préversion, et cet environnement utilise encore la %@. Déplacer l'environnement le fait passer sur cette révision%@ et garde le jeu et tout le reste installés. La configuration de Windows se relance, ce qui prend une minute ou deux. Highball ne pose la question qu'une fois, et le réglage Moteur de l'environnement permet de le déplacer plus tard.",
"This installs the dependencies the compatibility database verified.":
"Ceci installe les dépendances vérifiées par la base de compatibilité.",
"Sets this game up the way the compatibility database verified it — renderer, settings, dependencies.":
diff --git a/Sources/HighballKit/EngineChannels.swift b/Sources/HighballKit/EngineChannels.swift
index 9f88a92..3de62dc 100644
--- a/Sources/HighballKit/EngineChannels.swift
+++ b/Sources/HighballKit/EngineChannels.swift
@@ -49,4 +49,14 @@ public enum EngineChannels {
!visible(manifest, beta: beta, preview: preview, optedIn: optedIn) else { return nil }
return manifest
}
+
+ /// Whether an environment on `current` already runs the preview line `offer` belongs to: an earlier revision the
+ /// player took for the game. Play then counts the later revision as theirs too and offers the move
+ /// (Recipe.previewRevisionToOffer) instead of asking whether to use a preview engine they already use. The line
+ /// decides, with the bundled offer's channel saying it is in preview, whatever the installed copy of the current
+ /// engine's manifest carries.
+ public static func runsLine(current: EngineManifest, of offer: EngineManifest) -> Bool {
+ guard offer.channel == Self.preview, let line = EngineManifest.line(of: current.id) else { return false }
+ return line == EngineManifest.line(of: offer.id)
+ }
}
diff --git a/Sources/HighballKit/Recipe.swift b/Sources/HighballKit/Recipe.swift
index dfbf7e0..b4aef5f 100644
--- a/Sources/HighballKit/Recipe.swift
+++ b/Sources/HighballKit/Recipe.swift
@@ -665,6 +665,19 @@ public extension Recipe {
.max { (EngineManifest.revision(of: $0.id) ?? 0) < (EngineManifest.revision(of: $1.id) ?? 0) } ?? wanted
}
+ /// The later revision to offer an environment this recipe was applied to while it runs an earlier revision of the
+ /// preview line the recipe pins: Microsoft Flight Simulator 2024 set up on r3 when its recipe moved to r5
+ /// (2026-10-19). The engine ask comes only before a recipe is applied, so nothing else would offer it, and a
+ /// preview line moves fast. Nil for every other line: a Wine 10 or Wine 11 environment never moves on its own. The
+ /// offer's bundled manifest says whether the line is in preview, as in EngineChannels.runsLine.
+ func previewRevisionToOffer(current: EngineManifest, known: [EngineManifest],
+ macOS: String = Machine.macOSVersion()) -> EngineManifest? {
+ guard let id = engine, let line = EngineManifest.line(of: current.id), line == EngineManifest.line(of: id),
+ let offer = engineToOffer(current: current, known: known, macOS: macOS),
+ offer.channel == EngineChannels.preview, EngineManifest.line(of: offer.id) == line else { return nil }
+ return offer
+ }
+
/// The engine this recipe names when no manifest this build ships carries it and the
/// environment is not already on it or a later revision of its line: the fix reached the
/// database before the Highball that ships its engine (The Last Flame's r11 pin,
diff --git a/Tests/HighballKitTests/EngineChannelsTests.swift b/Tests/HighballKitTests/EngineChannelsTests.swift
index dc31625..8575cbd 100644
--- a/Tests/HighballKitTests/EngineChannelsTests.swift
+++ b/Tests/HighballKitTests/EngineChannelsTests.swift
@@ -71,6 +71,36 @@ final class EngineChannelsTests: XCTestCase {
XCTAssertNil(EngineChannels.previewToOffer(pin: nil, bundled: bundled, beta: false, preview: false, optedIn: []))
}
+ private func recipe(engine: String) throws -> Recipe {
+ let json = "{\"id\": \"game\", \"kind\": \"game\", \"title\": \"Game\", \"steps\": [], \"engine\": \"\(engine)\"}"
+ return try JSONDecoder().decode(Recipe.self, from: Data(json.utf8))
+ }
+
+ /// Microsoft Flight Simulator 2024 set up on r3 while its recipe now pins r5 (2026-10-19): the environment runs the
+ /// line already, so Play offers the move rather than the preview ask or a launch on r3.
+ func testAnEnvironmentOnAnEarlierPreviewRevisionIsOfferedThePinnedOne() throws {
+ let r3 = try manifest(id: "arm64-line-r3", channel: "preview")
+ let r5 = try manifest(id: "arm64-line-r5", channel: "preview")
+ let otherLine = try manifest(id: "arm64-other-r5", channel: "preview")
+ let x64 = try manifest(id: "x64-line-r21", channel: nil)
+ let x64Later = try manifest(id: "x64-line-r24", channel: nil)
+ XCTAssertTrue(EngineChannels.runsLine(current: r3, of: r5))
+ XCTAssertFalse(EngineChannels.runsLine(current: r3, of: otherLine))
+ XCTAssertFalse(EngineChannels.runsLine(current: x64, of: r5))
+
+ let game = try recipe(engine: "arm64-line-r5")
+ XCTAssertEqual(game.previewRevisionToOffer(current: r3, known: [r3, r5], macOS: "27.0")?.id, "arm64-line-r5")
+ XCTAssertNil(game.previewRevisionToOffer(current: r5, known: [r3, r5], macOS: "27.0"), "already on it")
+ XCTAssertNil(game.previewRevisionToOffer(current: r3, known: [r3], macOS: "27.0"), "a revision this install does not see")
+ XCTAssertNil(game.previewRevisionToOffer(current: otherLine, known: [otherLine, r5], macOS: "27.0"), "another line")
+ // The line decides, not the channel the installed copy of the current engine's manifest carries.
+ let r3Installed = try manifest(id: "arm64-line-r3", channel: nil)
+ XCTAssertTrue(EngineChannels.runsLine(current: r3Installed, of: r5))
+ XCTAssertEqual(game.previewRevisionToOffer(current: r3Installed, known: [r3, r5], macOS: "27.0")?.id, "arm64-line-r5")
+ // A Wine 10 or Wine 11 environment never moves on its own, whatever its recipe pins.
+ XCTAssertNil(try recipe(engine: "x64-line-r24").previewRevisionToOffer(current: x64, known: [x64, x64Later], macOS: "27.0"))
+ }
+
func testEveryEngineThePlayersHaveTodayHasNoChannel() throws {
let dir = repo.appending(path: "spike/engines")
let files = try FileManager.default.contentsOfDirectory(at: dir, includingPropertiesForKeys: nil)
diff --git a/spike/engines/arm64-wine11.18-r5.json b/spike/engines/arm64-wine11.18-r5.json
new file mode 100644
index 0000000..0459373
--- /dev/null
+++ b/spike/engines/arm64-wine11.18-r5.json
@@ -0,0 +1,85 @@
+{
+ "$schema": "https://highball.app/schemas/engine-manifest/v0",
+ "id": "arm64-wine11.18-r5",
+ "displayName": "Wine 11.18 native arm64 (preview) r5",
+ "arch": "arm64",
+ "minMacOS": "15.0",
+ "requires": [],
+ "channel": "preview",
+ "direct3D9": "wined3d",
+ "notes": [
+ "r5 (2026-10-19): far less stutter in Microsoft Flight Simulator 2024. The stutter was the game's main thread translating code again after the game's copy protection rewrote it, about 220 page invalidations a second in the memory that also holds the game's own code. FEX patch 0023 adds switches the game's recipe turns on: a store that writes back the bytes already in memory no longer throws the page's translations away (a third of those writes), code on a page the protection just wrote is translated in small units for a few seconds (multiblock translated about four times what runs there), translations whose bytes come back are reinstated (FEX 0020), and FEX's global locks are out of the paths that do not need them. On a base M4 at Gibraltar in daylight (Medium, FSR Balanced, 1920x931 windowed), against r4 with the same recipe otherwise: frames over 100 ms fell from 59 to 5 per 2-minute park and from 55 to 23 per minute of take-off roll, frames over 250 ms from 9 to 0.5 and from 7.5 to 2.2, the 99th percentile frame time from 160 to 71 ms parked and from 220 to 122 ms rolling, and the frame rate rose from 19 to 22.5 parked and from 16 to 19 rolling (four flights against two, three windows of each kind a flight; p < 0.001 parked and rolling).",
+ "Also since r3: an unhandled exception in an x86-64 program logs its full register state (patches-arm64 0041), RtlIsEcCode answers FALSE above the user address space instead of faulting until the stack runs out (0042), and a program sees the page protection it set rather than FEX's write trap (FEX 0022, Wine 0043). Wine 11.18 with patches-arm64 0001 to 0043, FEX 2610 with fex/patches 0001 to 0023; MoltenVK and the renderers are r3's. Every 0023 switch is off unless a recipe sets it: other games run as on r4.",
+ "Known: about one boot in sixteen to forty ends in a crash during the world load (a thread resumes with a wrong stack pointer; under study); a half-second GPU stall on the terrain pass, zero to two a flight; the launch takes about seven minutes to the start screen and four more to the cockpit on warm caches; lights drawn as point sprites and some line effects are missing (Metal has no geometry shaders); far map tiles on the Free Flight page stay coarse; motion blur is best off. A 16 GB Mac is unlikely to hold the game's 25 GB footprint.",
+ "Environments on this engine are new ones: an environment never moves between an Intel engine and this line. The engine's renderers are the vkd3d and dxvk folders of the renderers component, loaded through WINEDLLPATH as on the Intel line."
+ ],
+ "components": {
+ "wine": {
+ "kind": "engine",
+ "url": "https://github.com/gauthierpiarrette/highball-engine/releases/download/engine-arm64-wine-11.18-20261019T070308Z-skip-same-0023/engine-arm64-wine-11.18-20261019T070308Z-skip-same-0023.tar.gz",
+ "size": 402873163,
+ "sha256": "97a95cd26f1e0d301508b9485b3dfc8f7f594095f6a48d7f95d84149b0f909bf",
+ "extract": {
+ "into": "engine",
+ "subpath": "engine"
+ },
+ "license": "LGPL-2.1+",
+ "version": "wine-11.18 (WineHQ) Highball arm64 build 2026-10-19, patches-arm64 0001-0043, FEX 2610 with fex/patches 0001-0023, Wine Mono 11.3.0 and Gecko 2.47.4 included",
+ "note": "Built from WineHQ's wine-11.18.tar.xz (sha pinned in highball-engine/inputs-arm64.json) by highball-engine's build-arm64 workflow (run 39211986448, branch fex-smc-skip-same: not on main yet, the release is not published) with llvm-mingw 20260922 for the ARM64X PE side and FEX from source under Wine's emulator names (xtajit64.dll, xtajit.dll); the FEX helper libarm64ecfex.so carries AliasWrite, which patch 0019 needs, and ZeroPages, which 0023's HB_FEX_HOST_ZERO uses, and the FEX DLL exports GuestProtection for ntdll (0022, 0043). Stripped. The host libraries Wine opens by name (MoltenVK, FreeType, GnuTLS, SDL) and what they link sit in engine/lib (patch 0030). The archive also holds the frameworks folder."
+ },
+ "frameworks": {
+ "kind": "frameworks",
+ "url": "https://github.com/gauthierpiarrette/highball-engine/releases/download/engine-arm64-wine-11.18-20261019T070308Z-skip-same-0023/engine-arm64-wine-11.18-20261019T070308Z-skip-same-0023.tar.gz",
+ "size": 402873163,
+ "sha256": "97a95cd26f1e0d301508b9485b3dfc8f7f594095f6a48d7f95d84149b0f909bf",
+ "extract": {
+ "into": "frameworks",
+ "subpath": "frameworks"
+ },
+ "license": "mixed (LGPL-2.1 GStreamer 1.28.7 and its plugins, Apache-2.0 MoltenVK inside the GStreamer framework)",
+ "version": "GStreamer 1.28.7 (the official macOS framework, pruned to the plugins winegstreamer uses, with applemedia for VideoToolbox decoding, thinned to arm64)",
+ "note": "The same archive as the wine component, its frameworks folder; the store downloads it once."
+ },
+ "moltenvk": {
+ "kind": "runtime",
+ "order": 1,
+ "url": "https://github.com/gauthierpiarrette/highball-engine/releases/download/moltenvk-arm64-1.4.2-20261017T003752Z-r3/moltenvk-arm64-1.4.2-20261017T003752Z-r3.tar.gz",
+ "size": 1594975,
+ "sha256": "98403baf8ffd3f10497ef7205ece8cde699ba2d88a1d7275856e668678e957fb",
+ "extract": {
+ "into": "engine/lib/libMoltenVK.dylib",
+ "subpath": "lib/libMoltenVK.dylib"
+ },
+ "license": "Apache-2.0",
+ "version": "MoltenVK 1.4.2 with Highball's moltenvk-arm64 patches 0001-0016 and SPIRV-Cross patches 0001-0004 (r3's)",
+ "note": "Replaces the engine's own libMoltenVK.dylib in engine/lib, the one Wine's winevulkan opens on this line (so it installs after the wine component). Built by highball-engine's build-moltenvk-arm64 workflow (run 38783118608). 0001 rebinds descriptor sets after MoltenVK's helpers, 0011 keeps attachment-less render passes within the GPU's size limit, 0012 keeps an implicit pipeline cache per game and device on disk."
+ },
+ "renderers": {
+ "kind": "renderer",
+ "url": "https://github.com/gauthierpiarrette/highball-engine/releases/download/renderers-arm64-20261015T181326Z-arm64-r1/renderers-arm64-20261015T181326Z-arm64-r1.tar.gz",
+ "size": 11817971,
+ "sha256": "9476a69f2b4fc63c4da25888e1d36a41e5f1884f7c39809e1c03c1c577e15136",
+ "extract": {
+ "into": "renderers",
+ "subpath": "renderers"
+ },
+ "license": "mixed (LGPL-2.1 vkd3d-proton, zlib DXVK)",
+ "version": "vkd3d-proton 3.1 and DXVK 3.1 for MoltenVK, ARM64EC builds with highball-engine's renderers-arm64 patches",
+ "note": "renderers/vkd3d/wine (d3d12, d3d12core, dxgi, d3d11, d3d10core as native DLLs) and renderers/dxvk/wine, loaded through WINEDLLPATH when the environment's graphics mode is vkd3d or dxvk. Built by build-renderers-arm64 (run 38783123603)."
+ }
+ },
+ "baseEnv": {
+ "GST_PLUGIN_PATH": "${frameworks}/GStreamer.framework/Versions/1.0/lib/gstreamer-1.0",
+ "WINEDEBUG": "fixme-all",
+ "MVK_CONFIG_SHADER_SOURCE_COMPRESSION_ALGORITHM": "1",
+ "MVK_CONFIG_RESUME_LOST_DEVICE": "1",
+ "DXVK_RELAX_FEATURES": "1"
+ },
+ "verified": {
+ "date": "2026-10-19",
+ "macos": "27.0",
+ "chip": "Apple M4",
+ "result": "Steam copy of Microsoft Flight Simulator 2024 on a Mac mini M4 with 32 GB through Highball's test harness, the recipe's FEX switches on: boot, Free Flight, a Cessna 172 at Gibraltar, three 2-minute parks and three 1-minute take-off rolls with two in-game restarts a flight, in daylight. Flights hunt104 (FEX DLL built on the M4 from the same source), hunt107, hunt110 and hunt111 (this archive): no crash, no unhandled exception, no GPU hang (hunt111 had two of the known half-second terrain-pass stalls, and it went on), about 7 minutes to the start screen and 13 to the cockpit; 5 frames over 100 ms per 2-minute park (r4: 59), 22.5 fps parked and 19 rolling (r4: 19 and 16). The x86-64 fidelity programs pass with the switches on, 64 and 32-bit. Not tested: camera turns, other aircraft or airports, a long session, other Macs."
+ },
+ "licenses": {}
+}