diff --git a/apps/solvecraft/src/main.rs b/apps/solvecraft/src/main.rs
index a1a56dcb..531f5212 100644
--- a/apps/solvecraft/src/main.rs
+++ b/apps/solvecraft/src/main.rs
@@ -200,6 +200,8 @@ fn main() -> eframe::Result {
             if let Some(rs) = &cc.wgpu_render_state {
                 eprintln!("SolidCraft graphics: {:?}, MSAA {}x (requested {}x)", rs.adapter.get_info().backend, rs.msaa_samples, samples);
                 app.set_wgpu(rs, DEPTH_BITS, STENCIL_BITS, rs.msaa_samples);
+                // A saved anti-aliasing the device can't do: back to the default, with a notice.
+                solvecraft_ui_egui::prefs::check_msaa(&mut app, u32::from(samples));
             }
             if let Some(port) = control_port {
                 let rx = control_server::start(port, cc.egui_ctx.clone());
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 6e007d72..4e812b21 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -239,6 +239,11 @@ pub struct SolveApp {
     pub recoverable: Vec<solvecraft_engine::recovery::Entry>,
     /// The bodies of a just-opened Y-up file, offered to be stood up (`stand_up`).
     pub stand_up: Option<Vec<String>>,
+    /// The anti-aliasing sample counts the graphics device supports (empty without a GPU).
+    pub msaa_supported: Vec<u32>,
+    /// Settings put back at start because they kept SolidCraft from starting, one line each,
+    /// shown until dismissed (`prefs::show_reset_notice`).
+    pub settings_reset: Vec<prefs::SettingReset>,
     /// The last command was a big operation: autosave after it.
     pub big_operation: bool,
     /// Autosave interval (minutes; 0 = only after big operations). A preference.
@@ -300,6 +305,8 @@ impl SolveApp {
             autosave: None,
             recoverable: Vec::new(),
             stand_up: None,
+            msaa_supported: Vec::new(),
+            settings_reset: Vec::new(),
             big_operation: false,
             autosave_minutes: 5.0,
             custom_titlebar: false,
@@ -335,6 +342,7 @@ impl SolveApp {
     /// stencil buffer bits and MSAA sample count). Without it the viewport renders on the CPU.
     pub fn set_wgpu(&mut self, rs: &egui_wgpu::RenderState, depth_bits: u8, stencil_bits: u8, samples: u32) {
         self.viewport.gpu = Some(gpu::install(rs, depth_bits, stencil_bits, samples));
+        self.msaa_supported = rs.msaa_supported.clone();
         let info = rs.adapter.get_info();
         self.help.gpu = Some(format!("{} ({:?}, {:?})", info.name.trim(), info.backend, info.device_type));
     }
@@ -412,7 +420,10 @@ impl SolveApp {
         if let Some(t) = v.get("toolbar") {
             self.toolbar_custom.load(t);
         }
-        if let Some(p) = v.get("preferences").and_then(|p| serde_json::from_value::<prefs::Prefs>(p.clone()).ok()) {
+        if let Some(mut p) = v.get("preferences").and_then(|p| serde_json::from_value::<prefs::Prefs>(p.clone()).ok()) {
+            if !prefs::MSAA.contains(&p.msaa) {
+                p.msaa = prefs::Prefs::default().msaa;
+            }
             self.preferences = p;
         }
         // Saved before the theme was a preference: the Dark/Light flag says which.
@@ -1004,6 +1015,7 @@ impl SolveApp {
         params_dialog::show(self, ui.ctx());
         recovery_ui::show(self, ui.ctx());
         stand_up::show(self, ui.ctx());
+        prefs::show_reset_notice(self, ui.ctx());
         context_menu::show(self, ui.ctx());
         delete::show(self, ui.ctx());
         if self.custom_titlebar {
diff --git a/crates/ui-egui/src/locales/de.json b/crates/ui-egui/src/locales/de.json
index adbfc42b..53a5a4d7 100644
--- a/crates/ui-egui/src/locales/de.json
+++ b/crates/ui-egui/src/locales/de.json
@@ -11,6 +11,11 @@
   "dialog.selected_count": "↖ {count} ausgewählt",
   "document.save_changes": "Änderungen in {name} speichern?",
   "document.unsaved_changes": "{name} enthält ungespeicherte Änderungen. Wenn Sie nicht speichern, gehen sie verloren.",
+  "settings.msaa_applies_on_restart": "Die Kantenglättung wird beim nächsten Start von SolidCraft übernommen",
+  "settings.msaa_reset": "{setting}: {requested}× wird von diesem Grafikgerät nicht unterstützt; jetzt {reset}× (unterstützt: {supported}).",
+  "settings.msaa_unsupported": "Von diesem Grafikgerät nicht unterstützt",
+  "settings.reset_intro": "Diese Einstellungen funktionieren auf diesem Computer nicht und würden den Start von SolidCraft verhindern. Sie wurden daher geändert:",
+  "settings.reset_title": "Einstellungen wurden geändert",
   "sketch.degrees_of_freedom": "{count} Freiheitsgrade",
   "sketch.draw_curves": "{linetype}-Kurven zeichnen",
   "sketch.make_selection": "Auswahl als {linetype} markieren",
@@ -27,6 +32,7 @@
   "ui.animate_view_changes": "Ansichtsänderungen animieren",
   "ui.animation": "Animation",
   "ui.animation_speed": "Animationsgeschwindigkeit",
+  "ui.anti_aliasing": "Kantenglättung",
   "ui.apply": "Anwenden",
   "ui.arc": "Kreisbogen",
   "ui.assemble": "Zusammenbau",
@@ -199,6 +205,7 @@
   "ui.one_side": "Einseitig",
   "ui.open": "Öffnen",
   "ui.open_ellipsis": "Öffnen...",
+  "ui.open_preferences": "Einstellungen öffnen",
   "ui.open_recent": "Zuletzt verwendet",
   "ui.operation": "Operation",
   "ui.options": "Optionen",
diff --git a/crates/ui-egui/src/locales/en.json b/crates/ui-egui/src/locales/en.json
index b0feae8a..c96a5537 100644
--- a/crates/ui-egui/src/locales/en.json
+++ b/crates/ui-egui/src/locales/en.json
@@ -11,6 +11,11 @@
   "dialog.selected_count": "↖ {count} selected",
   "document.save_changes": "Save changes to {name}?",
   "document.unsaved_changes": "{name} has unsaved changes. If you don't save, they are lost.",
+  "settings.msaa_applies_on_restart": "Anti-aliasing applies the next time SolidCraft starts",
+  "settings.msaa_reset": "{setting}: {requested}× isn't supported by this graphics device; it is now {reset}× (supported: {supported}).",
+  "settings.msaa_unsupported": "Not supported by this graphics device",
+  "settings.reset_intro": "These settings don't work on this computer and would keep SolidCraft from starting, so they were changed:",
+  "settings.reset_title": "Settings were changed",
   "sketch.degrees_of_freedom": "{count} degrees of freedom",
   "sketch.draw_curves": "Draw {linetype} curves",
   "sketch.make_selection": "Make the selection {linetype}",
@@ -27,6 +32,7 @@
   "ui.animate_view_changes": "Animate view changes",
   "ui.animation": "Animation",
   "ui.animation_speed": "Animation speed",
+  "ui.anti_aliasing": "Anti-aliasing",
   "ui.apply": "Apply",
   "ui.arc": "Arc",
   "ui.assemble": "Assemble",
@@ -199,6 +205,7 @@
   "ui.one_side": "One Side",
   "ui.open": "Open",
   "ui.open_ellipsis": "Open...",
+  "ui.open_preferences": "Open Preferences",
   "ui.open_recent": "Open Recent",
   "ui.operation": "Operation",
   "ui.options": "Options",
diff --git a/crates/ui-egui/src/locales/ja.json b/crates/ui-egui/src/locales/ja.json
index 199385db..169685d0 100644
--- a/crates/ui-egui/src/locales/ja.json
+++ b/crates/ui-egui/src/locales/ja.json
@@ -11,6 +11,11 @@
   "dialog.selected_count": "↖ {count} 個選択",
   "document.save_changes": "{name} への変更を保存しますか？",
   "document.unsaved_changes": "{name} には保存されていない変更があります。保存しない場合、変更内容は失われます。",
+  "settings.msaa_applies_on_restart": "アンチエイリアスは次回 SolidCraft を起動したときに適用されます",
+  "settings.msaa_reset": "{setting}: {requested}× はこのグラフィックスデバイスではサポートされていないため、{reset}× に変更しました（サポート: {supported}）。",
+  "settings.msaa_unsupported": "このグラフィックスデバイスではサポートされていません",
+  "settings.reset_intro": "次の設定はこのコンピューターでは使用できず、SolidCraft が起動できなくなるため変更されました:",
+  "settings.reset_title": "設定が変更されました",
   "sketch.degrees_of_freedom": "自由度 {count}",
   "sketch.draw_curves": "{linetype}の曲線を描く",
   "sketch.make_selection": "選択を{linetype}にする",
@@ -27,6 +32,7 @@
   "ui.animate_view_changes": "視点変更をアニメーション表示",
   "ui.animation": "アニメーション",
   "ui.animation_speed": "アニメーション速度",
+  "ui.anti_aliasing": "アンチエイリアス",
   "ui.apply": "適用",
   "ui.arc": "円弧",
   "ui.assemble": "アセンブリ",
@@ -199,6 +205,7 @@
   "ui.one_side": "片側",
   "ui.open": "開く",
   "ui.open_ellipsis": "開く...",
+  "ui.open_preferences": "環境設定を開く",
   "ui.open_recent": "最近使った項目を開く",
   "ui.operation": "操作",
   "ui.options": "オプション",
diff --git a/crates/ui-egui/src/locales/ko.json b/crates/ui-egui/src/locales/ko.json
index e3c1b940..8175a12f 100644
--- a/crates/ui-egui/src/locales/ko.json
+++ b/crates/ui-egui/src/locales/ko.json
@@ -11,6 +11,11 @@
   "dialog.selected_count": "↖ {count}개 선택됨",
   "document.save_changes": "{name}의 변경 사항을 저장하시겠습니까?",
   "document.unsaved_changes": "{name}에 저장되지 않은 변경 사항이 있습니다. 저장하지 않으면 변경 사항이 사라집니다.",
+  "settings.msaa_applies_on_restart": "안티앨리어싱은 다음에 SolidCraft를 시작할 때 적용됩니다",
+  "settings.msaa_reset": "{setting}: {requested}×는 이 그래픽 장치에서 지원되지 않아 {reset}×로 변경했습니다(지원: {supported}).",
+  "settings.msaa_unsupported": "이 그래픽 장치에서 지원되지 않음",
+  "settings.reset_intro": "다음 설정은 이 컴퓨터에서 작동하지 않아 SolidCraft를 시작할 수 없게 하므로 변경되었습니다:",
+  "settings.reset_title": "설정이 변경되었습니다",
   "sketch.degrees_of_freedom": "자유도 {count}개",
   "sketch.draw_curves": "{linetype} 곡선 그리기",
   "sketch.make_selection": "선택 항목을 {linetype}(으)로 변경",
@@ -27,6 +32,7 @@
   "ui.animate_view_changes": "뷰 변경 애니메이션",
   "ui.animation": "애니메이션",
   "ui.animation_speed": "애니메이션 속도",
+  "ui.anti_aliasing": "안티앨리어싱",
   "ui.apply": "적용",
   "ui.arc": "호",
   "ui.assemble": "조립",
@@ -199,6 +205,7 @@
   "ui.one_side": "한 방향",
   "ui.open": "열기",
   "ui.open_ellipsis": "열기...",
+  "ui.open_preferences": "환경 설정 열기",
   "ui.open_recent": "최근 항목 열기",
   "ui.operation": "작업",
   "ui.options": "옵션",
diff --git a/crates/ui-egui/src/prefs.rs b/crates/ui-egui/src/prefs.rs
index f811712d..a3504eb4 100644
--- a/crates/ui-egui/src/prefs.rs
+++ b/crates/ui-egui/src/prefs.rs
@@ -158,6 +158,7 @@ pub fn nav_preset(id: &str) -> &'static NavPreset {
 pub const PAGES: [&str; 7] = ["General", "Navigation", "Keyboard Shortcuts", "Design", "Graphics", "Sketch", "Selection"];
 pub const PAGE_SHORTCUTS: usize = 2;
 pub const PAGE_DESIGN: usize = 3;
+pub const PAGE_GRAPHICS: usize = 4;
 pub const THEMES: [(&str, &str); 3] = [("dark", "Dark"), ("light", "Light"), ("system", "System")];
 pub const MSAA: [u32; 4] = [1, 2, 4, 8];
 
@@ -332,7 +333,7 @@ fn defaults(app: &mut SolveApp, page: usize) {
             p.up_axis = d.up_axis;
             p.offer_stand_up = d.offer_stand_up;
         }
-        4 => {
+        PAGE_GRAPHICS => {
             let msaa = p.msaa != d.msaa;
             p.msaa = d.msaa;
             app.ui.visual_style = 0;
@@ -520,6 +521,77 @@ fn save_graphics(app: &SolveApp) {
     }
 }
 
+/// At start, with the graphics device known: the saved anti-aliasing (`requested` samples, as
+/// the host read it) is more than the device supports. The window would not have opened with it,
+/// so the renderer fell back; put the setting back to its default (or the largest supported
+/// count below it) and tell the user what changed.
+pub fn check_msaa(app: &mut SolveApp, requested: u32) {
+    let supported = &app.msaa_supported;
+    if requested <= 1 || supported.is_empty() || supported.contains(&requested) {
+        return;
+    }
+    let default = Prefs::default().msaa;
+    let reset = supported.iter().copied().filter(|&n| n <= default).max().unwrap_or(1);
+    let supported = supported.clone();
+    app.preferences.msaa = reset;
+    save_graphics(app);
+    app.settings_reset.push(SettingReset::Msaa { requested, reset, supported });
+}
+
+/// A setting put back at start because it would keep SolidCraft from starting.
+#[derive(Clone, Debug, PartialEq)]
+pub enum SettingReset {
+    /// Anti-aliasing samples the graphics device can't render with.
+    Msaa { requested: u32, reset: u32, supported: Vec<u32> },
+}
+
+impl SettingReset {
+    /// The line the notice shows, in the current interface language.
+    pub fn message(&self) -> String {
+        match self {
+            SettingReset::Msaa { requested, reset, supported } => {
+                let setting = format!("{} › {}", crate::i18n::tr("ui.graphics"), crate::i18n::tr("ui.anti_aliasing"));
+                let supported = supported.iter().map(|n| format!("{n}")).collect::<Vec<_>>().join("×, ") + "×";
+                crate::i18n::format(
+                    "settings.msaa_reset",
+                    &[("setting", &setting), ("requested", &requested.to_string()), ("reset", &reset.to_string()), ("supported", &supported)],
+                )
+            }
+        }
+    }
+}
+
+/// Settings put back at start (`SolveApp::settings_reset`), until dismissed.
+pub fn show_reset_notice(app: &mut SolveApp, ctx: &egui::Context) {
+    if app.settings_reset.is_empty() {
+        return;
+    }
+    let mut ok = false;
+    let mut prefs = false;
+    crate::frame::window(ctx, app.tr("settings.reset_title"), crate::frame::Width::Normal)
+        .id(egui::Id::new("sc_settings_reset"))
+        .collapsible(false)
+        .resizable(false)
+        .show(ctx, |ui| {
+            ui.label(app.tr("settings.reset_intro"));
+            ui.add_space(4.0);
+            for reset in &app.settings_reset {
+                ui.label(format!("• {}", reset.message()));
+            }
+            ui.add_space(6.0);
+            ui.horizontal(|ui| {
+                ok = ui.button(app.tr("ui.heading_ok")).clicked();
+                prefs = ui.button(app.tr("ui.open_preferences")).clicked();
+            });
+        });
+    if ok || prefs {
+        app.settings_reset.clear();
+    }
+    if prefs {
+        open_at(app, PAGE_GRAPHICS);
+    }
+}
+
 pub fn show(app: &mut SolveApp, ctx: &egui::Context) {
     // File › Keyboard Shortcuts and Help › Keyboard Shortcuts open this dialog at that page.
     if app.keymap.open {
@@ -646,7 +718,6 @@ const PREFS_NAV_W: f32 = 128.0;
 
 /// One page of the dialog.
 fn page(app: &mut SolveApp, ui: &mut egui::Ui, t: &Tokens) {
-    let _language = crate::i18n::scope(&app.preferences.language);
     let note = |ui: &mut egui::Ui, s: &str| {
         ui.label("");
         // Descriptions wrap within the page instead of widening it.
@@ -801,14 +872,18 @@ fn page(app: &mut SolveApp, ui: &mut egui::Ui, t: &Tokens) {
             ui.label("Perspective view");
             ui.checkbox(&mut app.ui.perspective, "");
             ui.end_row();
-            ui.label("Anti-aliasing");
+            ui.label(app.tr("ui.anti_aliasing"));
             egui::ComboBox::from_id_salt("pref_msaa").selected_text(format!("{}×", app.preferences.msaa)).show_ui(ui, |ui| {
                 for m in MSAA {
-                    ui.selectable_value(&mut app.preferences.msaa, m, format!("{m}×"));
+                    // Counts the graphics device can't do would keep the window from opening.
+                    let ok = app.msaa_supported.is_empty() || app.msaa_supported.contains(&m);
+                    ui.add_enabled_ui(ok, |ui| ui.selectable_value(&mut app.preferences.msaa, m, format!("{m}×")))
+                        .inner
+                        .on_disabled_hover_text(app.tr("settings.msaa_unsupported"));
                 }
             });
             ui.end_row();
-            note(ui, "Anti-aliasing applies the next time SolidCraft starts");
+            note(ui, app.tr("settings.msaa_applies_on_restart"));
             ui.label("Renderer");
             ui.label(match (&app.viewport.gpu, &app.help.gpu) {
                 (Some(_), Some(g)) => format!("GPU: {g}"),
@@ -888,6 +963,9 @@ pub fn set(app: &mut SolveApp, p: &serde_json::Value) -> Result<serde_json::Valu
     if !NAV_PRESETS.iter().any(|p| p.id == new.nav) || !MSAA.contains(&new.msaa) {
         return Err("`nav` must be fusion, solidworks, inventor, alias, tinkercad or openscad and `msaa` 1, 2, 4 or 8".into());
     }
+    if new.msaa != app.preferences.msaa && !app.msaa_supported.is_empty() && !app.msaa_supported.contains(&new.msaa) {
+        return Err(format!("this graphics device doesn't support `msaa` {}; it supports {:?}", new.msaa, app.msaa_supported));
+    }
     if !THEMES.iter().any(|(id, _)| *id == new.theme) || !["z", "y"].contains(&new.up_axis.as_str()) {
         return Err("`theme` must be dark, light or system and `up_axis` z or y".into());
     }
@@ -916,6 +994,59 @@ pub fn set(app: &mut SolveApp, p: &serde_json::Value) -> Result<serde_json::Valu
 mod tests {
     use super::*;
 
+    #[test]
+    fn unsupported_saved_msaa_is_reset_to_the_default_with_a_notice() {
+        let dir = std::env::temp_dir().join(format!("sc_msaa_reset_{}", std::process::id()));
+        let _ = std::fs::create_dir_all(&dir);
+        let path = dir.join("graphics.json");
+        let services = crate::Services { graphics_path: Some(path.to_string_lossy().to_string()), ..Default::default() };
+        let mut app = SolveApp::new(solvecraft_engine::Session::default(), services);
+        // WebGPU's guarantee for the surface format: 8x saved, the device can only do 1x and 4x.
+        app.msaa_supported = vec![1, 4];
+        app.preferences.msaa = 8;
+        check_msaa(&mut app, 8);
+        assert_eq!(app.preferences.msaa, 4);
+        let saved: serde_json::Value = serde_json::from_str(&std::fs::read_to_string(&path).unwrap_or_default()).unwrap_or_default();
+        assert_eq!(saved["msaa"], 4);
+        assert_eq!(app.settings_reset, [SettingReset::Msaa { requested: 8, reset: 4, supported: vec![1, 4] }]);
+        assert_eq!(
+            app.settings_reset[0].message(),
+            "Graphics › Anti-aliasing: 8× isn't supported by this graphics device; it is now 4× (supported: 1×, 4×)."
+        );
+        {
+            let _de = crate::i18n::scope("de");
+            assert_eq!(
+                app.settings_reset[0].message(),
+                "Grafik › Kantenglättung: 8× wird von diesem Grafikgerät nicht unterstützt; jetzt 4× (unterstützt: 1×, 4×)."
+            );
+        }
+        // Below the default when the device can't do that either.
+        app.settings_reset.clear();
+        app.msaa_supported = vec![1, 2];
+        check_msaa(&mut app, 8);
+        assert_eq!(app.preferences.msaa, 2);
+        // Supported, off, or no GPU: nothing changes (OpenGL's 1x policy isn't a reset either).
+        for (supported, requested) in [(vec![1, 2, 4, 8], 8), (vec![1, 4], 1), (vec![], 8), (vec![1, 4], 4)] {
+            app.settings_reset.clear();
+            app.preferences.msaa = requested;
+            app.msaa_supported = supported;
+            check_msaa(&mut app, requested);
+            assert!(app.settings_reset.is_empty());
+            assert_eq!(app.preferences.msaa, requested);
+        }
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn control_channel_rejects_msaa_the_device_cannot_do_and_bad_saved_msaa_loads_as_default() {
+        let mut app = SolveApp::new(solvecraft_engine::Session::default(), crate::Services::default());
+        app.msaa_supported = vec![1, 4];
+        assert!(set(&mut app, &serde_json::json!({ "msaa": 8 })).is_err());
+        assert!(set(&mut app, &serde_json::json!({ "msaa": 1 })).is_ok());
+        app.load_prefs(&serde_json::json!({ "preferences": { "msaa": 16 } }).to_string());
+        assert_eq!(app.preferences.msaa, Prefs::default().msaa);
+    }
+
     #[test]
     fn length_fields_read_bare_numbers_in_design_units_and_honour_explicit_units() {
         let inch = unit_scale("in").0;
diff --git a/vendor/README.md b/vendor/README.md
index e0ec2d0b..5808b0e4 100644
--- a/vendor/README.md
+++ b/vendor/README.md
@@ -87,3 +87,9 @@ SolidCraft changes:
   exposing the effective sample count so host paint callbacks can match it.
 - `src/winit.rs`: use that same effective count for depth and resolve attachments.
 - Other backends retain requested MSAA, without another adapter or device probe.
+- `src/lib.rs`: clamp MSAA to the largest sample count the device supports for the surface and
+  depth formats (`supported_msaa_samples`, `RenderState::msaa_supported`): a saved 8x on a
+  device without it failed pipeline validation, a panic at start.
+- `src/setup.rs`: the default device requests `TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES` when
+  the adapter has it, so 2x and 8x work where the adapter supports them (WebGPU only
+  guarantees 1x and 4x).
diff --git a/vendor/egui-wgpu/src/lib.rs b/vendor/egui-wgpu/src/lib.rs
index 08eee42b..b07e4528 100644
--- a/vendor/egui-wgpu/src/lib.rs
+++ b/vendor/egui-wgpu/src/lib.rs
@@ -131,6 +131,10 @@ pub struct RenderState {
     /// Custom paint callbacks must use this, rather than the requested setting.
     pub msaa_samples: u32,
 
+    /// SolidCraft: the MSAA sample counts this device can render the target (and depth) format
+    /// with, ascending, always starting with 1.
+    pub msaa_supported: Vec<u32>,
+
     /// Egui renderer responsible for drawing the UI.
     pub renderer: Arc<RwLock<Renderer>>,
 
@@ -284,8 +288,19 @@ impl RenderState {
         // SolidCraft: the OpenGL resolve path can present an entirely black frame with MSAA
         // (notably Mesa/llvmpipe). Decide after selecting the real surface adapter,
         // before creating either pipelines or attachments; no second GPU probe.
+        // A sample count the device doesn't support for the target or depth format fails
+        // pipeline validation (a panic at start): fall back to the largest supported one.
+        let msaa_supported =
+            supported_msaa_samples(&adapter, &device, target_format, options.depth_stencil_format);
+        let wanted = effective_msaa_samples(adapter.get_info().backend, options.msaa_samples);
+        let msaa_samples = clamp_msaa_samples(&msaa_supported, wanted);
+        if msaa_samples != wanted {
+            log::warn!(
+                "MSAA {wanted}x is not supported for {target_format:?} on this device (supported: {msaa_supported:?}); using {msaa_samples}x"
+            );
+        }
         let options = RendererOptions {
-            msaa_samples: effective_msaa_samples(adapter.get_info().backend, options.msaa_samples),
+            msaa_samples,
             ..options
         };
         let renderer = Renderer::new(&device, target_format, options);
@@ -302,6 +317,7 @@ impl RenderState {
             queue,
             target_format,
             msaa_samples: options.msaa_samples,
+            msaa_supported,
             renderer: Arc::new(RwLock::new(renderer)),
             surface_config: config.surface,
         })
@@ -571,6 +587,58 @@ pub fn effective_msaa_samples(backend: wgpu::Backend, requested: u32) -> u32 {
     if backend == wgpu::Backend::Gl { 1 } else { requested.max(1) }
 }
 
+/// SolidCraft: the MSAA sample counts `device` can render `target_format` and
+/// `depth_stencil_format` with (ascending, always starting with 1). Without
+/// [`wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES`] the device allows only the counts
+/// WebGPU guarantees for a format (1 and 4), whatever the adapter could do.
+pub fn supported_msaa_samples(
+    adapter: &wgpu::Adapter,
+    device: &wgpu::Device,
+    target_format: wgpu::TextureFormat,
+    depth_stencil_format: Option<wgpu::TextureFormat>,
+) -> Vec<u32> {
+    let features = device.features();
+    let flags = |format: wgpu::TextureFormat| {
+        if features.contains(wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES) {
+            adapter.get_texture_format_features(format).flags
+        } else {
+            format.guaranteed_format_features(features).flags
+        }
+    };
+    let target = flags(target_format);
+    let depth = depth_stencil_format.map(flags);
+    msaa_counts(target, depth)
+}
+
+/// The sample counts both the colour target and the depth buffer support. A multisampled colour
+/// target must also resolve into the single-sampled surface.
+fn msaa_counts(
+    target: wgpu::TextureFormatFeatureFlags,
+    depth: Option<wgpu::TextureFormatFeatureFlags>,
+) -> Vec<u32> {
+    let resolves = target.contains(wgpu::TextureFormatFeatureFlags::MULTISAMPLE_RESOLVE);
+    [1, 2, 4, 8, 16]
+        .into_iter()
+        .filter(|&n| {
+            n == 1
+                || (resolves
+                    && target.sample_count_supported(n)
+                    && depth.is_none_or(|d| d.sample_count_supported(n)))
+        })
+        .collect()
+}
+
+/// SolidCraft: the largest of the `supported` sample counts that is at most `requested` (1 when
+/// none is).
+pub fn clamp_msaa_samples(supported: &[u32], requested: u32) -> u32 {
+    supported
+        .iter()
+        .copied()
+        .filter(|&n| n <= requested.max(1))
+        .max()
+        .unwrap_or(1)
+}
+
 #[cfg(test)]
 mod msaa_tests {
     #[test]
@@ -582,4 +650,23 @@ mod msaa_tests {
             }
         }
     }
+
+    #[test]
+    fn unsupported_sample_counts_fall_back_to_the_largest_supported_one() {
+        use wgpu::TextureFormatFeatureFlags as F;
+        // WebGPU's guarantee for Bgra8Unorm without adapter-specific features: 1 and 4 (a
+        // saved 8x failed pipeline validation at start).
+        let guaranteed = F::MULTISAMPLE_X4 | F::MULTISAMPLE_RESOLVE;
+        let supported = super::msaa_counts(guaranteed, Some(F::MULTISAMPLE_X4));
+        assert_eq!(supported, [1, 4]);
+        assert_eq!(super::clamp_msaa_samples(&supported, 8), 4);
+        assert_eq!(super::clamp_msaa_samples(&supported, 2), 1);
+        assert_eq!(super::clamp_msaa_samples(&supported, 0), 1);
+        // The depth buffer limits it too, and a target that can't resolve can't multisample.
+        let adapter = F::MULTISAMPLE_X2 | F::MULTISAMPLE_X4 | F::MULTISAMPLE_X8 | F::MULTISAMPLE_RESOLVE;
+        assert_eq!(super::msaa_counts(adapter, None), [1, 2, 4, 8]);
+        assert_eq!(super::msaa_counts(adapter, Some(F::MULTISAMPLE_X4)), [1, 4]);
+        assert_eq!(super::msaa_counts(F::MULTISAMPLE_X4, None), [1]);
+        assert_eq!(super::clamp_msaa_samples(&[], 8), 1);
+    }
 }
diff --git a/vendor/egui-wgpu/src/setup.rs b/vendor/egui-wgpu/src/setup.rs
index 3c9ceae5..ef2fa48b 100644
--- a/vendor/egui-wgpu/src/setup.rs
+++ b/vendor/egui-wgpu/src/setup.rs
@@ -272,6 +272,10 @@ impl WgpuSetupCreateNew {
                         max_texture_dimension_2d: 8192,
                         ..base_limits
                     },
+                    // SolidCraft: without it only the sample counts WebGPU guarantees (1x, 4x)
+                    // are allowed, even where the adapter supports 2x and 8x.
+                    required_features: adapter.features()
+                        & wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES,
                     ..Default::default()
                 }
             }),