From 6c9afc6f7e08672c802b4f3fb37a80529e86dfe2 Mon Sep 17 00:00:00 2001 From: TaeHeon Kim <94126603+NStevenU@users.noreply.github.com> Date: Fri, 30 Oct 2026 13:48:19 +0000 Subject: [PATCH] Start the window on OCLP Macs with SYSTEM_VERSION_COMPAT=1 (#3080) (#8930) On Macs patched with OpenCore Legacy Patcher the OS reports a newer macOS version than the GPU's Metal compiler supports, so wgpu picks a shader standard the compiler refuses (`invalid value 'metal3.2'`) and the window never draws. The variable has to be set before the process starts, and Rust 2024 makes `set_var` unsafe (this crate denies unsafe code), so main() now re-launches the binary with SYSTEM_VERSION_COMPAT=1 when the OCLP NVRAM key (OCLP-Version) is present, and exits with the child's status. A process that already has the variable set never re-launches, so there is no loop and a user's own value is respected. If the check or the spawn fails, startup continues normally. Tested on an OCLP Mac: one re-launch message, graphics render correctly; with SYSTEM_VERSION_COMPAT=1 set beforehand it does not re-launch. Co-authored-by: Claude Sonnet 5.5 --- apps/solidcraft/src/main.rs | 10 ++++ apps/solidcraft/src/startup.rs | 86 ++++++++++++++++++++++++++++++++++ 2 files changed, 96 insertions(+) diff --git a/apps/solidcraft/src/main.rs b/apps/solidcraft/src/main.rs index c492f980e..d9c6fbc9f 100644 --- a/apps/solidcraft/src/main.rs +++ b/apps/solidcraft/src/main.rs @@ -758,6 +758,16 @@ fn main() -> eframe::Result { #[cfg(target_os = "macos")] objc2_foundation::NSProcessInfo::processInfo().setProcessName(objc2_foundation::ns_string!("SolidCraft")); mark("main"); + // On OCLP-patched Macs, wgpu picks a Metal Shading Language standard that the system's + // compiler refuses (`invalid value 'metal3.2'`), because the patched OS reports a newer + // macOS version than the GPU's Metal compiler supports. Re-launching with + // SYSTEM_VERSION_COMPAT=1 makes the OS report the real (older) version so wgpu selects + // a standard the compiler accepts. The variable must be set before the process starts, so + // we detect OCLP here and re-exec immediately, before any macOS framework call (#3080, #4605). + #[cfg(target_os = "macos")] + if let Err(e) = startup::relaunch_with_version_compat() { + log::warn!("startup: OCLP check failed (continuing normally): {e}"); + } // Validate before legacy adoption, crash markers or any user preference read. let settings = settings_dir().map_err(|error| eframe::Error::AppCreation(error.into()))?; if std::env::var_os("SOLIDCRAFT_SETTINGS_DIR").is_none() { diff --git a/apps/solidcraft/src/startup.rs b/apps/solidcraft/src/startup.rs index a5fdbd403..718b8388c 100644 --- a/apps/solidcraft/src/startup.rs +++ b/apps/solidcraft/src/startup.rs @@ -292,6 +292,71 @@ pub fn window_instance_flags(flags: eframe::wgpu::InstanceFlags, intel_mac: bool if intel_mac && env.map(str::trim).is_none_or(str::is_empty) { flags - eframe::wgpu::InstanceFlags::VALIDATION_INDIRECT_CALL } else { flags } } +/// The environment variable that makes the macOS compatibility shim report an older OS +/// version to wgpu's Metal backend. On OCLP-patched machines the Metal compiler accepts +/// only up to the MSL standard of the original GPU, not the one the patched OS reports, +/// so wgpu picks a standard that the compiler refuses (`invalid value 'metal3.2'`). +/// Setting this variable before the process starts causes the OS to report the older +/// version and wgpu selects a supported MSL standard (#3080, #4605). +#[cfg(target_os = "macos")] +pub const SYSTEM_VERSION_COMPAT_ENV: &str = "SYSTEM_VERSION_COMPAT"; + +/// The NVRAM variable that OpenCore Legacy Patcher writes on every OCLP-booted system. +/// Its presence is the primary signal that `SYSTEM_VERSION_COMPAT=1` is needed. +#[cfg(target_os = "macos")] +pub const OCLP_NVRAM_KEY: &str = "4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102:OCLP-Version"; + +/// `true` if the OCLP NVRAM key is present on this system. +/// +/// Runs `nvram ` and treats exit 0 as present. Any error (missing binary, +/// permission denied, key absent) returns `false` — this is a best-effort probe. +#[cfg(target_os = "macos")] +pub fn oclp_nvram_present() -> bool { + std::process::Command::new("nvram").arg(OCLP_NVRAM_KEY).output().map(|o| o.status.success()).unwrap_or(false) +} + +/// Whether to re-launch with `SYSTEM_VERSION_COMPAT=1`: it is not set yet and OCLP shows through +/// the NVRAM key. The probe runs only when it is needed, so a re-launched process (variable +/// set) never starts `nvram`. +#[cfg(target_os = "macos")] +fn compat_wanted(compat_set: bool, nvram: impl FnOnce() -> bool) -> bool { + !compat_set && nvram() +} + +/// If this process is running under OCLP and `SYSTEM_VERSION_COMPAT` has not been set, +/// re-launch the current binary with `SYSTEM_VERSION_COMPAT=1` added to the environment, +/// then exit with the child's status code. +/// +/// `SYSTEM_VERSION_COMPAT=1` must be present **before** the process starts: setting it +/// with `std::env::set_var` inside `main` is too late because the macOS frameworks have +/// already queried the OS version by then. Re-launching is the only safe approach that +/// works without `unsafe` (a true `execve` replacement would require it). +/// +/// Returns `Ok(false)` immediately when: +/// - `SYSTEM_VERSION_COMPAT` is already set (re-launched process, no loop), or +/// - the OCLP NVRAM key is absent. +/// +/// Returns `Err` only when `std::env::current_exe()` fails or the child process cannot +/// be spawned; the caller should log the error and continue normally. +/// +/// Never returns `Ok(true)`: a successful re-launch exits the current process. +#[cfg(target_os = "macos")] +pub fn relaunch_with_version_compat() -> Result { + // A set variable means this is the re-launched process: no loop. + if !compat_wanted(std::env::var_os(SYSTEM_VERSION_COMPAT_ENV).is_some(), oclp_nvram_present) { + return Ok(false); + } + log::info!("startup: OCLP detected; re-launching with {}=1", SYSTEM_VERSION_COMPAT_ENV); + eprintln!("SolidCraft: OCLP detected; re-launching with {}=1", SYSTEM_VERSION_COMPAT_ENV); + let exe = std::env::current_exe().map_err(|e| format!("could not find own executable: {e}"))?; + let status = std::process::Command::new(&exe) + .args(std::env::args_os().skip(1)) + .env(SYSTEM_VERSION_COMPAT_ENV, "1") + .status() + .map_err(|e| format!("could not re-launch with {}: {e}", SYSTEM_VERSION_COMPAT_ENV))?; + std::process::exit(status.code().unwrap_or(1)); +} + /// Windows with OpenGL: the window keeps the system title bar (#2063). The window without OS /// decorations keeps its caption style while having no frame, and some OpenGL drivers (older /// Intel HD/UHD) then show the picture a caption's height lower than the window, so it no longer @@ -414,6 +479,27 @@ mod tests { assert_eq!(window_instance_flags(on, false, None), on); } + #[cfg(target_os = "macos")] + #[test] + fn oclp_relaunch_needs_the_signal_and_no_compat_variable() { + use super::compat_wanted; + let probed = std::cell::Cell::new(false); + let probe = |found: bool| { + let probed = &probed; + move || { + probed.set(true); + found + } + }; + // The re-launched process has the variable: no probe, no second re-launch. + assert!(!compat_wanted(true, probe(true))); + assert!(!probed.get()); + // The OCLP NVRAM key is the signal. + assert!(compat_wanted(false, probe(true))); + // No signal: an ordinary Mac starts as it is. + assert!(!compat_wanted(false, probe(false))); + } + #[test] fn switches_read_from_the_environment() { assert!(env_on(Some("1")) && env_on(Some("yes")) && !env_on(Some("0")) && !env_on(Some(" ")) && !env_on(None) && !env_on(Some("false")));