Fix #306: render on the power-saving GPU by default, with a preference for the discrete one

On hybrid-graphics laptops (an integrated GPU driving the display plus a
discrete one), egui-wgpu's default power preference is HighPerformance, so
VectorCraft rendered on the discrete GPU and its frames were copied to the
display through the integrated one. On an Asus ZenBook with Intel Iris + Arc
the window flickered whenever the mouse moved over it (#306, #305).

The canvas is rasterized on the CPU (vello_cpu) and the GPU only composites
the canvas texture and draws the UI, so the integrated GPU is plenty. The
desktop app now asks wgpu for the power-saving adapter by default.
Single-GPU machines are unaffected.

- Preferences > Performance > Graphics Processor (`gpuPreference`:
  powerSaving, the default, or highPerformance), with a note that it
  applies after a restart. The app reads it from the saved preferences
  before the window opens. WGPU_POWER_PREF still overrides it.
- Help > About and `ui.inspect` (`graphicsAdapter`) name the adapter in
  use, and it is logged at startup, for future GPU bug reports.
- Docs (README, docs/development.md) and ROADMAP updated.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

README.md

@@ -158,6 +158,10 @@ Japanese fonts come from [storytold/craft-fonts](https://github.com/storytold/cr
 build input (releases always use it): `CRAFT_FONTS_DIR="$PWD/../craft-fonts" cargo run --release -p vectorcraft` (an absolute path).
 Without it, Japanese text uses the installed system fonts. See [`docs/development.md`](docs/development.md#fonts-craft-fonts-optional-build-input).
 
+On laptops with two graphics processors, VectorCraft uses the power-saving (integrated) one by default.
+To use the discrete one, choose **Preferences › Performance › Graphics Processor › High Performance**
+and restart, or start the app with `WGPU_POWER_PREF=high` (see [`docs/development.md`](docs/development.md#desktop-graphics-processor)).
+
 ### Use it from Claude Code and other agents
 
 Register the MCP server with Claude Code:

ROADMAP.md

@@ -42,7 +42,7 @@ since 2026-10-01.
 | **Bundled content:** brush, symbol, style and swatch libraries | ~30% | Ours are original and generated in code, and far fewer than Illustrator ships; brush and symbol libraries are still missing |
 | **Performance** | unverified | Multithreaded, off-thread rendering and caches are in place. The last budget run (2026-10-01, loaded machine) measured 290 ms for a 50k-path fit against a 16 ms budget. Re-run `vectorcraft-cli perf` on an idle machine |
 | **Robustness** | good, new | ~2,840 tests, property tests, no panics in shipped code (lints, the `guard` safety net, import fuzzing), Data Recovery. Missing: a corpus of real-world files, Windows/Linux/browser QA |
-| **Platforms and 1.0 polish** | ~60% | The macOS app and the web build work; Windows/Linux packaging and accessibility are pending |
+| **Platforms and 1.0 polish** | ~60% | The macOS app and the web build work; hybrid-graphics laptops render on the power-saving GPU by default (#306); Windows/Linux packaging and accessibility are pending |
 | **Agent automation** | beyond Illustrator | Every command, gesture and dialog is drivable over MCP, the CLI and the control channel |
 
 ### Where we're lacking (in priority order)
@@ -141,6 +141,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
   - EPS and DXF in and out, EMF/WMF in and out; PNG (with PNG-8), JPEG, WebP, GIF, TIFF, BMP, Targa and layered PSD export. EPS import runs Illustrator's AGM/CoolType prologs (resource categories, `resourceforall`, `clipsave`/`cliprestore`, subarrays and substrings that share storage) and falls back to its palette TIFF preview. DXF TEXT justified Fit or Aligned spans its two points (stretched, or scaled as a whole).
   - Place and the Links panel, Package, File Info, Print with print presets, PostScript output and print tiling, slices and Save for Web, Export for Screens and Asset Export, CSS Properties, PNG/PDF/SVG/text clipboard flavours.
 - **Performance:** 20k shapes + 1k texts render in 27 ms per full-retina frame (7.8 ms zoomed), 7× faster than the first version. The UI thread never blocks. The web build is 7.1 MB gzipped.
+- **Graphics processor:** the canvas is rasterized on the CPU and the GPU only composites it, so the desktop app asks for the power-saving GPU by default (the integrated one on hybrid-graphics laptops, where presenting from the discrete GPU made the window flicker, #306). Preferences › Performance › Graphics Processor (`gpuPreference`) or `WGPU_POWER_PREF` picks the discrete one; Help › About and `ui.inspect` name the adapter in use.
 - **Tests and robustness:** ~2,840 automated tests: model-based property tests, a junk-parameter sweep over every command, import fuzzing (SVG, PDF, libraries), golden renders, and MCP end-to-end tests over stdio. Shipped code never panics (workspace lints and a rollback safety net; see `docs/development.md`).
 
 ## Milestones and estimates

apps/vectorcraft/src/main.rs

@@ -241,6 +241,27 @@ fn app_icon() -> egui::IconData {
     eframe::icon_data::from_png_bytes(png).unwrap_or_default()
 }
 
+/// The power preference wgpu picks the window's graphics adapter with (#306): the
+/// `WGPU_POWER_PREF` environment variable (`low`, `high`, `none`) when set, otherwise Preferences ›
+/// Performance › Graphics Processor (`gpuPreference`). Power saving unless the preference asks for
+/// high performance: the canvas is rasterized on the CPU and the GPU only composites it, which the
+/// integrated GPU of a hybrid-graphics laptop does easily, while presenting frames rendered on the
+/// discrete GPU through the integrated one made the window flicker on some laptops. With a single
+/// GPU both preferences pick it.
+fn power_preference(pref: Option<&str>, env: Option<eframe::wgpu::PowerPreference>) -> eframe::wgpu::PowerPreference {
+    use eframe::wgpu::PowerPreference;
+    match (env, pref) {
+        (Some(p), _) => p,
+        (None, Some("highPerformance")) => PowerPreference::HighPerformance,
+        (None, _) => PowerPreference::LowPower,
+    }
+}
+
+/// "name (backend, kind)" of the adapter the window renders with, for Help › About and bug reports.
+fn adapter_summary(info: &eframe::wgpu::AdapterInfo) -> String {
+    format!("{} ({:?}, {:?})", info.name.trim(), info.backend, info.device_type)
+}
+
 /// Windows and Linux: no OS title bar; the app bar is the title bar (`vectorcraft_ui_egui::titlebar`).
 /// macOS keeps its traffic lights over the integrated title strip.
 const CUSTOM_TITLEBAR: bool = !cfg!(target_os = "macos");
@@ -262,7 +283,9 @@ fn main() -> eframe::Result {
     }
     let saved = read_prefs();
     let saved_window = saved.as_ref().and_then(|ui| ui.window);
-    let options = eframe::NativeOptions {
+    let gpu_pref = saved.as_ref().and_then(|ui| ui.engine_prefs.get("gpuPreference")).and_then(serde_json::Value::as_str);
+    let power = power_preference(gpu_pref, eframe::wgpu::PowerPreference::from_env());
+    let mut options = eframe::NativeOptions {
         viewport: egui::ViewportBuilder::default()
             .with_title("VectorCraft")
             .with_inner_size(window::DEFAULT_SIZE)
@@ -276,6 +299,9 @@ fn main() -> eframe::Result {
             .with_app_id("ai.storyteller.vectorcraft"),
         ..Default::default()
     };
+    if let eframe::egui_wgpu::WgpuSetup::CreateNew(create) = &mut options.wgpu_options.wgpu_setup {
+        create.power_preference = power;
+    }
     eframe::run_native(
         "VectorCraft",
         options,
@@ -297,6 +323,11 @@ fn main() -> eframe::Result {
                 let recovery = prefs_path().and_then(|p| Some(p.parent()?.join("Data Recovery").to_string_lossy().to_string()));
                 app.session.recovery.set_default_folder(recovery);
             }
+            if let Some(rs) = &cc.wgpu_render_state {
+                let summary = adapter_summary(&rs.adapter.get_info());
+                log::info!("vectorcraft: rendering with {summary} (power preference {power:?})");
+                app.graphics_adapter = Some(summary);
+            }
             app.integrated_titlebar = cfg!(target_os = "macos");
             app.custom_titlebar = CUSTOM_TITLEBAR;
             if let Some(port) = control_port {
@@ -316,3 +347,35 @@ fn main() -> eframe::Result {
         }),
     )
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use eframe::wgpu::PowerPreference;
+
+    #[test]
+    fn power_saving_unless_the_preference_or_the_environment_says_otherwise() {
+        assert_eq!(power_preference(None, None), PowerPreference::LowPower);
+        assert_eq!(power_preference(Some("powerSaving"), None), PowerPreference::LowPower);
+        assert_eq!(power_preference(Some("highPerformance"), None), PowerPreference::HighPerformance);
+        // A value this version doesn't know (a newer or damaged preference file) is the default.
+        assert_eq!(power_preference(Some("turbo"), None), PowerPreference::LowPower);
+        assert_eq!(power_preference(Some(""), None), PowerPreference::LowPower);
+        // WGPU_POWER_PREF wins over the preference, either way.
+        assert_eq!(power_preference(Some("powerSaving"), Some(PowerPreference::HighPerformance)), PowerPreference::HighPerformance);
+        assert_eq!(power_preference(Some("highPerformance"), Some(PowerPreference::LowPower)), PowerPreference::LowPower);
+        assert_eq!(power_preference(None, Some(PowerPreference::None)), PowerPreference::None);
+    }
+
+    /// The preference the engine saves is the one the app reads back before the window opens.
+    #[test]
+    fn the_saved_engine_preference_is_found() {
+        let mut prefs = vectorcraft_engine::Prefs::default();
+        let saved = prefs.to_json();
+        assert_eq!(saved.get("gpuPreference").and_then(serde_json::Value::as_str), Some("powerSaving"));
+        prefs.gpu_preference = "highPerformance".into();
+        let saved = prefs.to_json();
+        let pref = saved.get("gpuPreference").and_then(serde_json::Value::as_str);
+        assert_eq!(power_preference(pref, None), PowerPreference::HighPerformance);
+    }
+}

crates/engine/src/cmd/prefscmds.rs

@@ -82,6 +82,8 @@ pub const UNITS: &[(&str, &str)] = &[
     ("feet", "Feet"),
 ];
 const LINE_STYLE: &[(&str, &str)] = &[("lines", "Lines"), ("dots", "Dots")];
+/// Performance › Graphics Processor (`gpuPreference`), read by the desktop app at startup.
+pub const GPU_PREFERENCES: &[(&str, &str)] = &[("powerSaving", "Power Saving (integrated)"), ("highPerformance", "High Performance (discrete)")];
 const BLACK: &[(&str, &str)] = &[("accurate", "Display All Blacks Accurately"), ("rich", "Display All Blacks as Rich Black")];
 const BLACK_OUT: &[(&str, &str)] = &[("accurate", "Output All Blacks Accurately"), ("rich", "Output All Blacks as Rich Black")];
 
@@ -265,6 +267,7 @@ pub const PREF_SPECS: &[PrefSpec] = &[
     // Performance
     p!("gpuPerformance", "Performance", "GPU Performance", "GPU Performance", bool),
     p!("animatedZoom", "Performance", "GPU Performance", "Animated Zoom", bool),
+    p!("gpuPreference", "Performance", "GPU Performance", "Graphics Processor", choice(GPU_PREFERENCES)),
     p!("historyStates", "Performance", "", "History States", int(5, 1000)),
     p!("realTimeDrawing", "Performance", "", "Real-time Drawing and Editing", bool),
     p!("renderThreads", "Performance", "", "Render Threads (-1 = Automatic)", int(-1, 64)),

crates/engine/src/lib.rs

@@ -397,6 +397,12 @@ pub struct Prefs {
     // Performance
     pub gpu_performance: bool,
     pub animated_zoom: bool,
+    /// Which graphics processor the desktop app asks for at startup (it takes effect after a
+    /// restart): `powerSaving` (the integrated GPU on hybrid-graphics laptops) or `highPerformance`
+    /// (the discrete one). The canvas is rasterized on the CPU and only composited on the GPU, so
+    /// the integrated GPU is plenty; presenting from the discrete GPU through the integrated one
+    /// made some hybrid laptops flicker (#306). Single-GPU machines are unaffected.
+    pub gpu_preference: String,
     pub history_states: u32,
     pub real_time_drawing: bool,
     /// Rasterizer worker threads; -1 = automatic.
@@ -598,6 +604,7 @@ impl Default for Prefs {
             interface_language: s("auto"),
             gpu_performance: true,
             animated_zoom: true,
+            gpu_preference: s("powerSaving"),
             history_states: 500,
             real_time_drawing: true,
             render_threads: -1,

crates/engine/src/tests_prefs.rs

@@ -122,3 +122,33 @@ fn prefs_serde_round_trip_and_tolerates_missing_fields() {
     assert_eq!(partial.keyboard_increment, 4.0);
     assert_eq!(partial.corner_radius, 12.0);
 }
+
+/// Performance › Graphics Processor (#306): power saving by default, set by value or label, kept
+/// through a save/load round trip, and a bad value is an error that changes nothing.
+#[test]
+fn gpu_preference_defaults_to_power_saving_and_validates() {
+    let mut s = Session::new();
+    assert_eq!(s.prefs.gpu_preference, "powerSaving");
+    assert_eq!(s.execute("prefs.get", &json!({"key": "gpuPreference"})).unwrap(), json!("powerSaving"));
+    s.execute("prefs.set", &json!({"key": "gpuPreference", "value": "highPerformance"})).unwrap();
+    assert_eq!(s.prefs.gpu_preference, "highPerformance");
+    s.execute("prefs.set", &json!({"key": "gpuPreference", "value": "Power Saving (integrated)"})).unwrap();
+    assert_eq!(s.prefs.gpu_preference, "powerSaving");
+    for bad in [json!("turbo"), json!(""), json!(1), json!(null), json!(["highPerformance"])] {
+        assert!(s.execute("prefs.set", &json!({"key": "gpuPreference", "value": bad})).is_err(), "{bad}");
+        assert_eq!(s.prefs.gpu_preference, "powerSaving");
+    }
+    let p = Prefs { gpu_preference: "highPerformance".into(), ..Default::default() };
+    let back: Prefs = serde_json::from_value(p.to_json()).unwrap();
+    assert_eq!(back.gpu_preference, "highPerformance");
+    // Preference files written before the preference existed get the default.
+    let old: Prefs = serde_json::from_value(json!({"gpuPerformance": true})).unwrap();
+    assert_eq!(old.gpu_preference, "powerSaving");
+    let l = s.execute("prefs.list", &json!({})).unwrap();
+    let row = l.as_array().unwrap().iter().find(|e| e["key"] == "gpuPreference").unwrap().clone();
+    assert_eq!(row["category"], "Performance");
+    assert_eq!(row["options"], json!(["powerSaving", "highPerformance"]));
+    s.execute("prefs.set", &json!({"key": "gpuPreference", "value": "highPerformance"})).unwrap();
+    s.execute("prefs.reset", &json!({"category": "Performance"})).unwrap();
+    assert_eq!(s.prefs.gpu_preference, "powerSaving");
+}

crates/ui-egui/src/control.rs

@@ -83,6 +83,7 @@ pub fn inspect(app: &VectorcraftApp, ctx: &egui::Context) -> Value {
         "documents": app.session.documents().iter().map(|d| json!({"title": d.title(), "dirty": d.is_dirty()})).collect::<Vec<_>>(),
         "activeDocument": app.session.active_index(),
         "perf": {"frameMs": app.perf.frame_ms, "renderMs": app.perf.render_ms, "fps": app.perf.fps},
+        "graphicsAdapter": app.graphics_adapter,
         // Saves and exports still being written in the background (Background Save / Export).
         "background": app.background.jobs.iter().map(|j| j.label.as_str()).collect::<Vec<_>>(),
     })

crates/ui-egui/src/dialogs/about.rs

@@ -37,6 +37,11 @@ pub(super) fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
                 ))
                 .size(11.0),
             );
+            // The GPU the window renders with, for bug reports (Preferences › Performance picks it).
+            if let Some(adapter) = &app.graphics_adapter {
+                ui.add_space(6.0);
+                ui.label(egui::RichText::new(crate::i18n::fmt(tl!("Graphics: {adapter}"), &[("adapter", adapter.as_str())])).size(11.0));
+            }
         });
     app.ui.about = open;
 }

crates/ui-egui/src/i18n/zh-hant.tsv

@@ -148,6 +148,7 @@
 	Appearance Panel	外觀面板
 	Appearance panel	外觀面板
 	Applies when the linked file is relinked or updated.	重新連結或更新連結檔案時套用。
+	Applies the next time VectorCraft starts.	下次啟動 VectorCraft 時生效。
 	Apply Brush	套用筆刷
 	Apply Character Style	套用字元樣式
 	Apply Effect	套用效果
@@ -1017,6 +1018,8 @@
 	Graphic Styles	繪圖樣式
 	Graphic Styles Options	繪圖樣式選項
 	Graphics	圖形
+	Graphics Processor	圖形處理器
+	Graphics: {adapter}	圖形：{adapter}
 	Gravity	重力
 	Grays	灰色
 	Grays and Neutrals	灰色與中性色
@@ -1073,6 +1076,7 @@
 	Hide Transparency Grid	隱藏透明度格點
 	High	高
 	High (300 ppi)	高 (300 ppi)
+	High Performance (discrete)	高效能 (獨立顯示卡)
 	Highlight Alternate Glyphs	醒目提示替代字符
 	Highlight anchors on mouse over	滑鼠移過時醒目提示錨點
 	Highlight Substituted Fonts	醒目提示被取代的字體
@@ -1775,6 +1779,7 @@
 	Polygon Properties:	多邊形內容：
 	Polygon Tool	多邊形工具
 	Portrait	直向
+	Power Saving (integrated)	節能 (內建顯示晶片)
 	Portuguese	葡萄牙文
 	Position	位置
 	Postcard	明信片

crates/ui-egui/src/lib.rs

@@ -293,6 +293,9 @@ pub struct VectorcraftApp {
     /// Windows and Linux: the window has no OS decorations, so the app bar is the title bar (drag,
     /// double-click to maximize, caption buttons) and invisible edge zones resize the window.
     pub custom_titlebar: bool,
+    /// The graphics adapter the window renders with ("name (backend)"), as the host reports it:
+    /// shown in Help › About and `ui.inspect` for GPU bug reports. `None` when unknown.
+    pub graphics_adapter: Option<String>,
     /// File → Place: picked files, the place cursor's thumbnails, the Control bar's image details.
     pub place: place::PlaceState,
     /// The Paste commands can paste from the system clipboard alone: it holds something to paste
@@ -367,6 +370,7 @@ impl VectorcraftApp {
             canvas_rect: None,
             hover_doc: None,
             custom_titlebar: false,
+            graphics_adapter: None,
             place: Default::default(),
             system_paste: false,
             system_paste_at: f64::NEG_INFINITY,

crates/ui-egui/src/prefs_dialog.rs

@@ -279,6 +279,10 @@ fn category_fields(ui: &mut egui::Ui, d: &mut Dialog, cat: &str) {
                         d.fields.insert(sp.key.into(), json!(opts[i].0));
                     }
                 });
+                if sp.key == "gpuPreference" {
+                    // The window's graphics device is chosen once, when the app starts.
+                    ui.label(egui::RichText::new(tl!("Applies the next time VectorCraft starts.")).color(t.text_dim).size(11.0));
+                }
             }
             PrefKind::Color => {
                 labeled(ui, sp.label, |ui| {
@@ -393,6 +397,38 @@ mod tests {
         assert_eq!(a.session.prefs.ui_brightness, "light");
     }
 
+    /// Performance › Graphics Processor (#306): shown with its restart note, applied by OK and
+    /// saved with the UI state under the key the desktop app reads before the window opens.
+    #[test]
+    fn graphics_processor_preference_shows_and_persists() {
+        fn texts(s: &egui::Shape, out: &mut Vec<String>) {
+            match s {
+                egui::Shape::Text(t) => out.push(t.galley.text().to_string()),
+                egui::Shape::Vec(v) => v.iter().for_each(|s| texts(s, out)),
+                _ => {}
+            }
+        }
+        let mut a = app();
+        open(&mut a, Some("Performance"));
+        let ctx = egui::Context::default();
+        crate::theme::install_fonts(&ctx);
+        // The window sizes itself on the first frame and draws on the second.
+        let mut out = ctx.run_ui(egui::RawInput::default(), |ui| show(&mut a, ui.ctx()));
+        out.textures_delta.clear();
+        let mut out = ctx.run_ui(egui::RawInput::default(), |ui| show(&mut a, ui.ctx()));
+        out.textures_delta.clear();
+        let mut shown = vec![];
+        out.shapes.iter().for_each(|c| texts(&c.shape, &mut shown));
+        assert!(shown.iter().any(|t| t.starts_with("Graphics Processor")), "{shown:?}");
+        assert!(shown.iter().any(|t| t == "Power Saving (integrated)"), "{shown:?}");
+        assert!(shown.iter().any(|t| t == "Applies the next time VectorCraft starts."), "{shown:?}");
+        a.ui.dialog.as_mut().unwrap().fields.insert("gpuPreference".into(), json!("highPerformance"));
+        confirm(&mut a).unwrap();
+        assert_eq!(a.session.prefs.gpu_preference, "highPerformance");
+        let saved: Value = serde_json::from_slice(&serde_json::to_vec(&a.ui).unwrap()).unwrap();
+        assert_eq!(saved["engine_prefs"]["gpuPreference"], json!("highPerformance"));
+    }
+
     #[test]
     fn every_category_renders_fields() {
         for c in PREF_CATEGORIES {

docs/development.md

@@ -24,6 +24,14 @@ How the web shell (`apps/vectorcraft-web/src/web.rs`) differs from desktop:
 - **No control server:** browsers can't listen on TCP. To automate the web build, drive headless Chrome with `--remote-debugging-port`.
 - Quick smoke test: `"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --headless=new --enable-unsafe-webgpu --screenshot=web.png --window-size=1440,900 --virtual-time-budget=15000 http://127.0.0.1:8766/` (headless Chrome on macOS gets a real WebGPU adapter).
 
+## Desktop graphics processor
+
+The canvas is rasterized on the CPU (`vectorcraft-render`, vello_cpu); the GPU (wgpu, through eframe) only composites the canvas texture and draws the UI. The desktop app (`apps/vectorcraft/src/main.rs`) therefore asks wgpu for the **power-saving** adapter by default, which is the integrated GPU on hybrid-graphics laptops. Presenting frames rendered on a discrete GPU through the integrated one made the window flicker on some laptops (#306). A machine with one GPU gets that GPU either way.
+
+- **Preferences › Performance › Graphics Processor** (`gpuPreference`: `powerSaving` or `highPerformance`) picks the other one. The adapter is chosen when the window opens, so a change applies after a restart.
+- The `WGPU_POWER_PREF` environment variable (`low`, `high` or `none`) overrides the preference.
+- Help › About and the control channel's `ui.inspect` (`graphicsAdapter`) show the adapter in use, and the app logs it at startup.
+
 ## Fonts: craft-fonts (optional build input)
 
 Font files are never committed to this repository. Fonts shared by the Crafting Apps live in