Merge upstream/main: keep panel normalization alongside dock collapse behavior

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/pdf/Cargo.toml

@@ -32,4 +32,6 @@ sha2 = { version = "0.10", default-features = false }
 
 [dev-dependencies]
 vectorcraft-testkit = { workspace = true }
+# A variable font built in code (no font file is committed).
+vectorcraft-text = { workspace = true, features = ["test-fonts"] }
 serde_json = { workspace = true }

crates/pdf/src/export.rs

@@ -1444,7 +1444,11 @@ impl Exporter<'_> {
         let name = format!("{} {}", face.family, face.style);
         let font = match face.embedding() {
             Embedding::Subset => {
-                let font = krilla::text::Font::new(face.file_data().to_vec().into(), face.face_index()).map(|f| (f, face.units_per_em()));
+                // A named instance of a variable font is embedded instanced (its own outlines and
+                // widths, not the default instance's).
+                let coords: Vec<(krilla::text::Tag, f32)> = face.variations().iter().map(|(t, v)| (krilla::text::Tag::new(t), *v)).collect();
+                let font =
+                    krilla::text::Font::new_variable(face.file_data().to_vec().into(), face.face_index(), &coords).map(|f| (f, face.units_per_em()));
                 if font.is_none() {
                     self.warn(format!("the font “{name}” can't be embedded: its text is exported as outlines"));
                 }

crates/pdf/src/tests_realtext.rs

@@ -110,6 +110,28 @@ fn real_text_lands_within_half_a_point_of_the_outlines() {
     }
 }
 
+/// A named instance of a variable font is real text in that instance: its embedded subset draws
+/// the instance's glyphs where the outlines would be, not the default instance's (#296).
+#[test]
+fn variable_font_instances_are_real_text_in_their_own_glyphs() {
+    use vectorcraft_text::test_fonts::{VARIABLE_CHARS, VARIABLE_FAMILY, variable_font};
+    FontDb::global().add_font(variable_font().unwrap());
+    let mut widths = vec![];
+    for s in ["Regular", "Bold"] {
+        let st = CharStyle { font_family: VARIABLE_FAMILY.into(), font_style: s.into(), ..style(48.0) };
+        let d = doc(vec![TextObject::point(Point::new(20.0, 80.0), VARIABLE_CHARS, st)]);
+        let r = pdf(&d, false);
+        assert!(r.warnings.is_empty(), "{s}: {:?}", r.warnings);
+        assert_eq!(texts(&import_as(&r.bytes, TextAs::Text)), [VARIABLE_CHARS], "{s}: real text");
+        let (real, outlined) = (ink(&import_as(&r.bytes, TextAs::Outlines)), ink(&import_as(&pdf(&d, true).bytes, TextAs::Outlines)));
+        let off =
+            [real.x0 - outlined.x0, real.y0 - outlined.y0, real.x1 - outlined.x1, real.y1 - outlined.y1].iter().fold(0.0f64, |m, v| m.max(v.abs()));
+        assert!(off < 0.5, "{s}: {real:?} vs {outlined:?}");
+        widths.push(real.width());
+    }
+    assert!(widths[1] > widths[0] * 1.2, "Bold is wider: {widths:?}");
+}
+
 #[test]
 fn gradients_on_real_text_stay_where_they_were() {
     let fill = Paint::Gradient(Box::new(GradientPaint::new(Gradient::default())));

crates/svg/Cargo.toml

@@ -30,6 +30,8 @@ svgtypes = "0.16"
 [dev-dependencies]
 # Reading embedded font subsets back.
 skrifa = { workspace = true }
+# A variable font built in code (no font file is committed).
+vectorcraft-text = { workspace = true, features = ["test-fonts"] }
 resvg = { version = "0.45", default-features = false }
 vectorcraft-testkit = { workspace = true }
 proptest = { workspace = true }

crates/svg/tests/encoding_profile_fonts.rs

@@ -216,6 +216,31 @@ fn embedded_fonts_hold_only_the_glyphs_used() {
     assert!(!export_full(&d, &ExportOptions { embed_fonts: true, outline_text: true, ..Default::default() }, None).svg.contains("@font-face"));
 }
 
+/// A named instance of a variable font embeds as a static font of that instance: the variable
+/// file would show its default instance in browsers (#296).
+#[test]
+fn variable_font_instances_embed_as_themselves() {
+    use vectorcraft_text::test_fonts::{VARIABLE_FAMILY, variable_font};
+    let db = vectorcraft_text::FontDb::global();
+    db.add_font(variable_font().unwrap());
+    let mut d = Document::new(300.0, 200.0);
+    add(&mut d, text(Point::new(20.0, 60.0), &[("ll", style(VARIABLE_FAMILY, "Regular")), ("ll", style(VARIABLE_FAMILY, "Bold"))]));
+    let o = export_full(&d, &ExportOptions { embed_fonts: true, ..Default::default() }, None);
+    let fonts = embedded(&o.svg);
+    assert_eq!(fonts.iter().map(|f| f.1).collect::<Vec<_>>(), [400, 700], "{:?}", o.warnings);
+    let mut advances = vec![];
+    for ((_, w, data), style) in fonts.iter().zip(["Regular", "Bold"]) {
+        let f = skrifa::FontRef::new(data).unwrap();
+        assert!(f.fvar().is_err() && f.gvar().is_err(), "{w}: a static font");
+        let gid = f.cmap().unwrap().map_codepoint('l').unwrap();
+        let adv = f.hmtx().unwrap().advance(gid).unwrap();
+        let face = db.face(VARIABLE_FAMILY, style).unwrap();
+        assert_eq!(f64::from(adv), face.advance(face.glyph_for('l')).round(), "{style}");
+        advances.push(adv);
+    }
+    assert!(advances[1] > advances[0], "{advances:?}");
+}
+
 /// The bundled Source Sans 3 Regular renamed `family` (13 characters, as long as the original
 /// name) with OS/2 `fsType` set to `fs_type`.
 fn licensed_font(family: &str, fs_type: u16) -> Vec<u8> {

crates/text/Cargo.toml

@@ -15,5 +15,16 @@ kurbo = { workspace = true }
 skrifa = { workspace = true }
 harfrust = { workspace = true }
 log = { workspace = true }
-# Font subsets for embedding (SVG @font-face); MIT OR Apache-2.0, already used by the PDF writer.
-subsetter = { version = "0.2", default-features = false }
+# Font subsets for embedding (SVG @font-face); MIT OR Apache-2.0, already used by the PDF writer
+# (which turns on `variable-fonts` too: named instances of variable fonts are instanced).
+subsetter = { version = "0.2", default-features = false, features = ["variable-fonts"] }
+# Builds a small variable font for tests (`test_fonts`; no font file is committed). MIT OR
+# Apache-2.0, already in the build through subsetter.
+write-fonts = { version = "0.48", optional = true }
+
+[features]
+# `vectorcraft_text::test_fonts` for other crates' tests (dev-dependencies only).
+test-fonts = ["dep:write-fonts"]
+
+[dev-dependencies]
+write-fonts = "0.48"

crates/text/src/embed.rs

@@ -60,19 +60,29 @@ impl FontFace {
 
     /// The face as a font file to embed: the glyphs of `chars` alone when its licence allows
     /// subsetting, else the whole face. Ligatures, kerning and other layout features are left out
-    /// of subsets (viewers draw each character's own glyph). `None` when the licence forbids
-    /// embedding or the font can't be read.
+    /// of subsets (viewers draw each character's own glyph). A named instance of a variable font
+    /// ([`FontFace::variations`]) is embedded as a static font of that instance (the variable file
+    /// would show its default instance), CFF2 outlines becoming TrueType ones. `None` when the
+    /// licence forbids embedding or the font can't be read.
     pub fn embed(&self, chars: &[char]) -> Option<EmbeddedFont> {
         let font = self.skrifa()?;
         let cff = [b"CFF ", b"CFF2"].iter().any(|t| font.table_data(Tag::new(t)).is_some());
         let whole = || Some(EmbeddedFont { data: sfnt(font.table_directory.sfnt_version(), tables(&font))?, cff, subset: false });
+        let instance = !self.variations().is_empty();
         match self.embedding() {
             Embedding::Forbidden => None,
+            // Every glyph of the instance, keeping their ids.
+            Embedding::Whole if instance => {
+                let all: Vec<char> = font.charmap().mappings().filter_map(|(c, _)| char::from_u32(c)).collect();
+                subset(self, &font, &all, true).map(|(data, cff)| EmbeddedFont { data, cff, subset: false })
+            }
             Embedding::Whole => whole(),
-            Embedding::Subset => match subset(self, &font, chars) {
-                Some(data) => Some(EmbeddedFont { data, cff, subset: true }),
-                // Outlines the subsetter can't read (CFF2): what the licence allows anyway.
-                None => whole(),
+            Embedding::Subset => match subset(self, &font, chars, false) {
+                Some((data, cff)) => Some(EmbeddedFont { data, cff, subset: true }),
+                // Outlines the subsetter can't read: what the licence allows anyway (a named
+                // instance can't be embedded whole, which would show the default instance).
+                None if !instance => whole(),
+                None => None,
             },
         }
     }
@@ -83,10 +93,17 @@ fn tables<'a>(font: &skrifa::FontRef<'a>) -> Vec<(Tag, Cow<'a, [u8]>)> {
     font.table_directory.table_records().iter().filter_map(|r| font.table_data(r.tag()).map(|d| (r.tag(), Cow::Borrowed(d.as_bytes())))).collect()
 }
 
-/// `face` reduced to the glyphs of `chars`, with a `cmap` mapping them and the face's `OS/2`.
-fn subset(face: &FontFace, font: &skrifa::FontRef<'_>, chars: &[char]) -> Option<Vec<u8>> {
+/// `face` reduced to the glyphs of `chars` (every glyph, keeping their ids, when `all`), with a
+/// `cmap` mapping them and the face's `OS/2`; a named instance instanced. Returns the font and
+/// whether its outlines are CFF ones.
+fn subset(face: &FontFace, font: &skrifa::FontRef<'_>, chars: &[char], all: bool) -> Option<(Vec<u8>, bool)> {
     let charmap = font.charmap();
     let mut remapper = subsetter::GlyphRemapper::new();
+    if all {
+        for gid in 0..font.maxp().ok()?.num_glyphs() {
+            remapper.remap(gid);
+        }
+    }
     let mut map: Vec<(u32, u16)> = chars
         .iter()
         .filter_map(|c| {
@@ -96,14 +113,20 @@ fn subset(face: &FontFace, font: &skrifa::FontRef<'_>, chars: &[char]) -> Option
         .collect();
     map.sort_unstable();
     map.dedup_by_key(|m| m.0);
-    let data = subsetter::subset(face.data(), face.index(), &remapper).ok()?;
+    let data = if face.variations().is_empty() {
+        subsetter::subset(face.data(), face.index(), &remapper).ok()?
+    } else {
+        let coords: Vec<(subsetter::Tag, f32)> = face.variations().iter().map(|(t, v)| (subsetter::Tag::new(t), *v)).collect();
+        subsetter::subset_with_variations(face.data(), face.index(), &coords, &remapper).ok()?
+    };
     let sub = skrifa::FontRef::new(&data).ok()?;
+    let cff = [b"CFF ", b"CFF2"].iter().any(|t| sub.table_data(Tag::new(t)).is_some());
     let mut t: Vec<(Tag, Cow<'_, [u8]>)> = tables(&sub).into_iter().filter(|(tag, _)| *tag != CMAP && *tag != OS2).collect();
     t.push((CMAP, Cow::Owned(cmap(&map)?)));
     if let Some(os2) = font.table_data(OS2) {
         t.push((OS2, Cow::Owned(os2_for(os2.as_bytes(), &map))));
     }
-    sfnt(sub.table_directory.sfnt_version(), t)
+    Some((sfnt(sub.table_directory.sfnt_version(), t)?, cff))
 }
 
 /// The face's `OS/2` table with its first and last character fitted to the subset's.

crates/text/src/fontdb.rs

@@ -7,11 +7,11 @@ use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
 use std::sync::{Arc, Mutex, RwLock};
 
 use kurbo::BezPath;
-use skrifa::instance::{LocationRef, Size};
+use skrifa::instance::{Location, LocationRef, Size};
 use skrifa::outline::{DrawSettings, OutlinePen};
 use skrifa::raw::FileRef;
 use skrifa::string::StringId;
-use skrifa::{GlyphId, MetadataProvider};
+use skrifa::{GlyphId, MetadataProvider, Tag};
 
 /// The family used when a requested family is unknown (Illustrator's Myriad Pro analogue).
 pub const FALLBACK_FAMILY: &str = "Source Sans 3";
@@ -28,6 +28,14 @@ static BUNDLED: &[&[u8]] = &[
     include_bytes!("../../../assets/fonts/JetBrainsMono-Regular.ttf"),
 ];
 
+/// An axis setting of a variable font: the axis tag (`wght`) and its value in user units (700).
+pub type Variation = ([u8; 4], f32);
+
+/// Caps on what a (possibly damaged) variable font can make the database read: axes per font and
+/// named instances listed per face.
+const MAX_AXES: usize = 64;
+const MAX_INSTANCES: usize = 512;
+
 enum FontBytes {
     Static(&'static [u8]),
     Owned(Arc<Vec<u8>>),
@@ -60,6 +68,13 @@ pub struct FontFace {
     pub(crate) cap_height: f64,
     pub(crate) x_height: f64,
     pub(crate) shaper: harfrust::ShaperData,
+    /// The axis settings of the variable font's named instance this face is (user units: `wght`
+    /// 700); empty for a static face or a variable font's default instance.
+    variations: Vec<Variation>,
+    /// [`Self::variations`] in the font's normalized design space (outlines and metrics).
+    location: Location,
+    /// [`Self::variations`] for the shaper (advances, kerning, feature variations).
+    pub(crate) instance: Option<harfrust::ShaperInstance>,
 }
 
 impl std::fmt::Debug for FontFace {
@@ -85,6 +100,17 @@ impl FontFace {
     pub(crate) fn index(&self) -> u32 {
         self.index
     }
+    /// Where in a variable font's design space the face's outlines and metrics are taken (the
+    /// default location for a static face).
+    pub(crate) fn location(&self) -> LocationRef<'_> {
+        LocationRef::from(&self.location)
+    }
+    /// The axis settings of the variable font's named instance this face is (`wght` 700 for
+    /// Bold), in user units; empty for a static face and a variable font's default instance.
+    /// The face's file holds the whole variable font: exporters that embed it pass these on.
+    pub fn variations(&self) -> &[Variation] {
+        &self.variations
+    }
     /// Unique id of this face within the process.
     pub fn id(&self) -> u32 {
         self.id
@@ -112,7 +138,7 @@ impl FontFace {
     /// Advance width of glyph `gid` in font units.
     pub fn advance(&self, gid: u32) -> f64 {
         self.skrifa()
-            .and_then(|f| f.glyph_metrics(Size::unscaled(), LocationRef::default()).advance_width(GlyphId::new(gid)))
+            .and_then(|f| f.glyph_metrics(Size::unscaled(), self.location()).advance_width(GlyphId::new(gid)))
             .map(|a| a as f64)
             .unwrap_or(self.upem * 0.5)
     }
@@ -147,8 +173,18 @@ impl FontFace {
 #[derive(Debug, Default)]
 struct CatalogFamily {
     name: String,
-    /// (style, file) of each face.
-    faces: Vec<(String, PathBuf)>,
+    faces: Vec<CatalogFace>,
+}
+
+/// One style of an installed family: a face, or a named instance of a variable font.
+#[derive(Debug)]
+#[cfg_attr(target_arch = "wasm32", allow(dead_code))]
+struct CatalogFace {
+    style: String,
+    path: PathBuf,
+    /// Weight and italic as the style lists them (by its name, or a named instance's axes).
+    weight: f32,
+    italic: bool,
 }
 
 /// The installed fonts by ASCII-lowercased family name (lookups ignore ASCII case, as
@@ -344,26 +380,103 @@ fn face_names(f: &skrifa::FontRef<'_>) -> Option<(String, String)> {
     Some((family, style))
 }
 
-/// Parse every face in `data` (a font file or collection). Returns `(index, family, style)`.
-fn enumerate_faces(data: &[u8]) -> Vec<(u32, String, String)> {
+/// One style a font file offers: one of its faces, or a named instance of a variable font
+/// (Figtree's `Figtree[wght].ttf` holds Light, the default, and Regular to Black as instances).
+#[derive(Clone, Debug)]
+pub(crate) struct FaceStyle {
+    family: String,
+    style: String,
+    keys: FaceKeys,
+    /// A named instance's axis settings (user units); empty for the face itself.
+    variations: Vec<Variation>,
+    /// A named instance's weight (its `wght` setting); `None` for the face itself (its OS/2 table
+    /// says) or an instance of a font without a weight axis.
+    weight: Option<f32>,
+    /// A named instance is italic (by its `ital` or `slnt` setting, or its name).
+    italic: bool,
+}
+
+/// The styles of a face: the face itself, then its named instances when it is a variable font.
+pub(crate) fn face_styles(f: &skrifa::FontRef<'_>) -> Vec<FaceStyle> {
+    let Some((family, style)) = face_names(f) else { return vec![] };
+    let mut keys = FaceKeys::of(f, &family, &style);
+    let instances = named_instances(f, &family, &style, &mut keys);
+    let face = FaceStyle { family, style, keys, variations: vec![], weight: None, italic: false };
+    std::iter::once(face).chain(instances).collect()
+}
+
+/// The named instances of a variable font face (its `fvar` table) as styles of the face's family,
+/// named by their subfamily names, without the default instance (the face itself) and without
+/// names already taken. The default instance's name, when it isn't the face's style name (a face
+/// `Regular` whose default instance is `Book`), names the face too (`keys`). Damaged tables give
+/// fewer instances or none; the counts read are capped.
+fn named_instances(f: &skrifa::FontRef<'_>, family: &str, style: &str, keys: &mut FaceKeys) -> Vec<FaceStyle> {
+    let axes = f.axes();
+    if axes.is_empty() || axes.len() > MAX_AXES {
+        return vec![];
+    }
+    let tags: Vec<Tag> = axes.iter().map(|a| a.tag()).collect();
+    let defaults: Vec<f32> = axes.iter().map(|a| a.default_value()).collect();
+    // Instances without a PostScript name of their own are named `<prefix>-<style>` (Adobe
+    // Technical Note #5902), as PDF and `.ai` files name them.
+    let prefix = name(f, &[StringId::VARIATIONS_POSTSCRIPT_NAME_PREFIX]).unwrap_or_else(|| family.to_string());
+    let mut taken = vec![norm(style)];
+    let mut out = Vec::new();
+    for inst in f.named_instances().iter().take(MAX_INSTANCES) {
+        let coords: Vec<f32> = inst.user_coords().take(MAX_AXES).collect();
+        if coords.len() != tags.len() || coords.iter().any(|c| !c.is_finite()) {
+            continue;
+        }
+        let Some(style) = name(f, &[inst.subfamily_name_id()]) else { continue };
+        let ns = norm(&style);
+        if ns.is_empty() || taken.contains(&ns) {
+            continue;
+        }
+        // The default instance is the face itself.
+        if coords.iter().zip(&defaults).all(|(c, d)| (c - d).abs() < 1e-3) {
+            keys.styles.push(ns.clone());
+            keys.postscript.push(norm(&format!("{prefix}{style}")));
+            taken.push(ns);
+            continue;
+        }
+        taken.push(ns);
+        let axis = |tag: &[u8; 4]| tags.iter().zip(&coords).find(|(t, _)| t.to_be_bytes() == *tag).map(|(_, v)| *v);
+        let weight = axis(b"wght").map(|w| w.clamp(1.0, 1000.0));
+        let italic = style_italic(&style) || axis(b"ital").is_some_and(|v| v >= 0.5) || axis(b"slnt").is_some_and(|v| v != 0.0);
+        let mut styles: Vec<String> = std::iter::once(style.clone()).chain(all_names(f, inst.subfamily_name_id())).map(|s| norm(&s)).collect();
+        let mut postscript: Vec<String> = inst.postscript_name_id().map(|id| all_names(f, id)).unwrap_or_default().iter().map(|n| norm(n)).collect();
+        postscript.push(norm(&format!("{prefix}{style}")));
+        for v in [&mut styles, &mut postscript] {
+            v.retain(|k| !k.is_empty());
+            v.sort();
+            v.dedup();
+        }
+        let keys = FaceKeys { families: keys.families.clone(), styles, legacy: vec![], postscript };
+        let variations = tags.iter().zip(&coords).map(|(t, v)| (t.to_be_bytes(), *v)).collect();
+        out.push(FaceStyle { family: family.to_string(), style, keys, variations, weight, italic });
+    }
+    out
+}
+
+/// Parse every face in `data` (a font file or collection) and the named instances of its variable
+/// ones. Returns each style with the index of its face.
+fn enumerate_faces(data: &[u8]) -> Vec<(u32, FaceStyle)> {
     let count = match FileRef::new(data) {
         Ok(FileRef::Font(_)) => 1,
         Ok(FileRef::Collection(c)) => c.len(),
         Err(_) => 0,
     };
     (0..count)
-        .filter_map(|i| {
-            let (family, style) = face_names(&skrifa::FontRef::from_index(data, i).ok()?)?;
-            Some((i, family, style))
-        })
+        .filter_map(|i| Some((i, skrifa::FontRef::from_index(data, i).ok()?)))
+        .flat_map(|(i, f)| face_styles(&f).into_iter().map(move |s| (i, s)))
         .collect()
 }
 
-/// (family, style, PostScript name) of every face in the font file at `path`, reading only its
-/// table directories and `name` tables: a scan opens hundreds of font files, many of them
+/// The styles of every face in the font file at `path` ([`face_styles`]), reading only its table
+/// directories and `name` and `fvar` tables: a scan opens hundreds of font files, many of them
 /// megabytes long.
 #[cfg(not(target_arch = "wasm32"))]
-fn file_face_names(path: &Path) -> Vec<(String, String, FaceKeys)> {
+fn file_face_names(path: &Path) -> Vec<FaceStyle> {
     use std::io::{Read, Seek, SeekFrom};
     /// Caps on what a (possibly damaged) file can make the scan read.
     const MAX_FACES: u32 = 256;
@@ -390,29 +503,55 @@ fn file_face_names(path: &Path) -> Vec<(String, String, FaceKeys)> {
             let dir = read_at(start.into(), 12)?;
             let tables = u16::from_be_bytes(dir.get(4..6)?.try_into().ok()?) as usize;
             let records = read_at(u64::from(start) + 12, tables * 16)?;
-            let rec: &[u8] = records.as_chunks::<16>().0.iter().find(|r| r.starts_with(b"name"))?;
-            let (offset, len) = (be32(rec, 8)?, be32(rec, 12)?);
-            if len > MAX_NAME_TABLE {
-                return None;
+            let mut table = |tag: &[u8; 4]| -> Option<Vec<u8>> {
+                let rec: &[u8] = records.as_chunks::<16>().0.iter().find(|r| r.starts_with(tag))?;
+                let (offset, len) = (be32(rec, 8)?, be32(rec, 12)?);
+                if len > MAX_NAME_TABLE {
+                    return None;
+                }
+                read_at(offset.into(), len as usize)
+            };
+            let name = table(b"name")?;
+            // A variable font's named instances are styles too.
+            let fvar = table(b"fvar");
+            // A font holding just these tables, to read them as the font itself would.
+            let mut tables: Vec<(&[u8; 4], &[u8])> = vec![(b"name", &name)];
+            if let Some(fvar) = &fvar {
+                tables.push((b"fvar", fvar));
             }
-            let table = read_at(offset.into(), len as usize)?;
-            // A one-table font holding just the `name` table, to read it as the font itself would.
-            let mut font = Vec::with_capacity(28 + table.len());
-            font.extend_from_slice(&0x0001_0000_u32.to_be_bytes());
-            font.extend_from_slice(&[0, 1, 0, 16, 0, 0, 0, 0]);
-            font.extend_from_slice(b"name");
-            for v in [0, 28, len] {
-                font.extend_from_slice(&u32::to_be_bytes(v));
-            }
-            font.extend_from_slice(&table);
-            let f = skrifa::FontRef::new(&font).ok()?;
-            let (family, style) = face_names(&f)?;
-            let keys = FaceKeys::of(&f, &family, &style);
-            Some((family, style, keys))
+            let font = sfnt_of(&tables)?;
+            Some(face_styles(&skrifa::FontRef::new(&font).ok()?))
         })
+        .flatten()
         .collect()
 }
 
+/// A font file holding `tables` (tag, data), sorted by tag as table directories are.
+#[cfg(any(test, not(target_arch = "wasm32")))]
+pub(crate) fn sfnt_of(tables: &[(&[u8; 4], &[u8])]) -> Option<Vec<u8>> {
+    let mut tables = tables.to_vec();
+    tables.sort_by_key(|t| *t.0);
+    let n = u16::try_from(tables.len()).ok()?;
+    let mut font = Vec::new();
+    font.extend_from_slice(&0x0001_0000_u32.to_be_bytes());
+    for v in [n, 0, 0, 0] {
+        font.extend_from_slice(&v.to_be_bytes());
+    }
+    let mut offset = 12 + 16 * tables.len();
+    for (tag, data) in &tables {
+        font.extend_from_slice(*tag);
+        for v in [0, u32::try_from(offset).ok()?, u32::try_from(data.len()).ok()?] {
+            font.extend_from_slice(&v.to_be_bytes());
+        }
+        offset += data.len().next_multiple_of(4);
+    }
+    for (_, data) in &tables {
+        font.extend_from_slice(data);
+        font.resize(font.len().next_multiple_of(4), 0);
+    }
+    Some(font)
+}
+
 /// The platform's font folders (the system's and the user's), scanned by [`FontDb::global`].
 pub fn system_font_dirs() -> Vec<PathBuf> {
     let mut dirs: Vec<PathBuf> = Vec::new();
@@ -448,23 +587,31 @@ pub fn system_font_dirs() -> Vec<PathBuf> {
     dirs
 }
 
-fn make_face(bytes: FontBytes, index: u32, family: String, style: String, path: Option<std::path::PathBuf>) -> Option<FontFace> {
+fn make_face(bytes: FontBytes, index: u32, spec: FaceStyle, path: Option<std::path::PathBuf>) -> Option<FontFace> {
     let data: &[u8] = match &bytes {
         FontBytes::Static(b) => b,
         FontBytes::Owned(v) => v.as_slice(),
     };
     let f = skrifa::FontRef::from_index(data, index).ok()?;
-    let m = f.metrics(Size::unscaled(), LocationRef::default());
+    let FaceStyle { family, style, keys, variations, weight, italic } = spec;
+    // A named instance: outlines, metrics and advances at its axis settings.
+    let location = if variations.is_empty() { Location::default() } else { f.axes().location(variations.iter().map(|(t, v)| (Tag::new(t), *v))) };
+    let m = f.metrics(Size::unscaled(), &location);
     let a = f.attributes();
-    let shaper = harfrust::ShaperData::new(&harfrust::FontRef::from_index(data, index).ok()?);
-    let keys = FaceKeys::of(&f, &family, &style);
+    let hb = harfrust::FontRef::from_index(data, index).ok()?;
+    let shaper = harfrust::ShaperData::new(&hb);
+    let instance =
+        (!variations.is_empty()).then(|| harfrust::ShaperInstance::from_variations(&hb, variations.iter().map(|(t, v)| (harfrust::Tag::new(t), *v))));
     Some(FontFace {
         keys,
         id: NEXT_ID.fetch_add(1, Ordering::Relaxed),
         family,
         style,
-        weight: a.weight.value(),
-        italic: !matches!(a.style, skrifa::attribute::Style::Normal),
+        weight: weight.unwrap_or(a.weight.value()),
+        italic: italic || !matches!(a.style, skrifa::attribute::Style::Normal),
+        variations,
+        location,
+        instance,
         upem: m.units_per_em.max(1) as f64,
         ascent: m.ascent as f64,
         descent: -(m.descent as f64),
@@ -523,8 +670,8 @@ impl FontDb {
         // first: fallbacks for Japanese text after the requested and bundled fonts.
         let craft = crate::craft_fonts::japanese_document_fonts().into_iter().map(|f| f.bytes);
         for data in BUNDLED.iter().copied().chain(craft) {
-            for (i, family, style) in enumerate_faces(data) {
-                if let Some(f) = make_face(FontBytes::Static(data), i, family, style, None) {
+            for (i, spec) in enumerate_faces(data) {
+                if let Some(f) = make_face(FontBytes::Static(data), i, spec, None) {
                     faces.push(Arc::new(f));
                 }
             }
@@ -631,9 +778,9 @@ impl FontDb {
         let mut v: Vec<(bool, f32, String)> =
             self.read_faces().iter().filter(|f| f.family.eq_ignore_ascii_case(family)).map(|f| (f.italic, f.weight, f.style.clone())).collect();
         if let Some(c) = self.read_catalog().get(&family.to_ascii_lowercase()) {
-            for (style, _) in &c.faces {
-                if !v.iter().any(|(_, _, s)| s.eq_ignore_ascii_case(style)) {
-                    v.push((style_italic(style), style_weight(style), style.clone()));
+            for cf in &c.faces {
+                if !v.iter().any(|(_, _, s)| s.eq_ignore_ascii_case(&cf.style)) {
+                    v.push((cf.italic, cf.weight, cf.style.clone()));
                 }
             }
         }
@@ -652,11 +799,11 @@ impl FontDb {
     fn add_font_from(&self, bytes: Vec<u8>, path: Option<&Path>) -> usize {
         let data = Arc::new(bytes);
         let mut added = 0;
-        for (i, family, style) in enumerate_faces(&data) {
-            if self.read_faces().iter().any(|f| f.family.eq_ignore_ascii_case(&family) && f.style.eq_ignore_ascii_case(&style)) {
+        for (i, spec) in enumerate_faces(&data) {
+            if self.read_faces().iter().any(|f| f.family.eq_ignore_ascii_case(&spec.family) && f.style.eq_ignore_ascii_case(&spec.style)) {
                 continue;
             }
-            if let Some(f) = make_face(FontBytes::Owned(data.clone()), i, family, style, path.map(Path::to_path_buf)) {
+            if let Some(f) = make_face(FontBytes::Owned(data.clone()), i, spec, path.map(Path::to_path_buf)) {
                 self.faces.write().unwrap_or_else(|e| e.into_inner()).push(Arc::new(f));
                 added += 1;
             }
@@ -722,7 +869,7 @@ impl FontDb {
                 if !matches!(ext.as_deref(), Some("ttf" | "otf" | "ttc" | "otc")) {
                     continue;
                 }
-                for (family, style, keys) in file_face_names(&p) {
+                for FaceStyle { family, style, keys, weight, italic, .. } in file_face_names(&p) {
                     for (k, a) in Alias::of(&family, &style, &keys) {
                         aliases.entry(k).or_default().push(a);
                     }
@@ -734,7 +881,8 @@ impl FontDb {
                     if entry.name.is_empty() {
                         entry.name = family;
                     }
-                    entry.faces.push((style, p.clone()));
+                    let (weight, italic) = (weight.unwrap_or_else(|| style_weight(&style)), italic || style_italic(&style));
+                    entry.faces.push(CatalogFace { style, path: p.clone(), weight, italic });
                     n += 1;
                 }
             }
@@ -824,7 +972,7 @@ impl FontDb {
     #[cfg(not(target_arch = "wasm32"))]
     fn load_cataloged(&self, family: &str) -> bool {
         let mut paths: Vec<PathBuf> =
-            self.read_catalog().get(&family.to_ascii_lowercase()).map(|c| c.faces.iter().map(|(_, p)| p.clone()).collect()).unwrap_or_default();
+            self.read_catalog().get(&family.to_ascii_lowercase()).map(|c| c.faces.iter().map(|cf| cf.path.clone()).collect()).unwrap_or_default();
         paths.sort();
         paths.dedup();
         let mut any = false;
@@ -867,7 +1015,7 @@ impl FontDb {
     #[cfg(not(target_arch = "wasm32"))]
     fn is_cataloged(&self, family: &str, style: &str) -> bool {
         let ns = norm(style);
-        self.read_catalog().get(&family.to_ascii_lowercase()).is_some_and(|c| c.faces.iter().any(|(s, _)| norm(s) == ns))
+        self.read_catalog().get(&family.to_ascii_lowercase()).is_some_and(|c| c.faces.iter().any(|cf| norm(&cf.style) == ns))
     }
 
     /// The loaded face with [`FontFace::id`] `id` (the face a laid-out glyph came from).
@@ -901,6 +1049,11 @@ impl FontDb {
         if let Some(f) = cands.iter().find(|f| norm(&f.style) == ns) {
             return Some((*f).clone());
         }
+        // Another of a face's style names: in another language, or a variable font's default
+        // instance's name.
+        if let Some(f) = cands.iter().find(|f| f.keys.styles.contains(&ns)) {
+            return Some((*f).clone());
+        }
         let (tw, ti) = (style_weight(style), style_italic(style));
         cands
             .iter()
@@ -958,7 +1111,7 @@ impl FontDb {
                 return true;
             }
         }
-        let mut paths: Vec<PathBuf> = self.read_catalog().values().flat_map(|c| c.faces.iter().map(|(_, p)| p.clone())).collect();
+        let mut paths: Vec<PathBuf> = self.read_catalog().values().flat_map(|c| c.faces.iter().map(|cf| cf.path.clone())).collect();
         paths.sort();
         paths.dedup();
         for p in paths {
@@ -966,8 +1119,7 @@ impl FontDb {
                 continue;
             }
             let Ok(data) = std::fs::read(&p) else { continue };
-            let hit =
-                enumerate_faces(&data).iter().any(|(i, _, _)| skrifa::FontRef::from_index(&data, *i).is_ok_and(|f| f.charmap().map(c).is_some()));
+            let hit = enumerate_faces(&data).iter().any(|(i, _)| skrifa::FontRef::from_index(&data, *i).is_ok_and(|f| f.charmap().map(c).is_some()));
             if hit && self.add_font_from(data, Some(&p)) > 0 && covered(self) {
                 return true;
             }
@@ -986,7 +1138,7 @@ impl FontDb {
         if let Some(f) = face.skrifa()
             && let Some(g) = f.outline_glyphs().get(GlyphId::new(gid))
         {
-            let _ = g.draw(DrawSettings::unhinted(Size::unscaled(), LocationRef::default()), &mut pen);
+            let _ = g.draw(DrawSettings::unhinted(Size::unscaled(), face.location()), &mut pen);
         }
         let p = Arc::new(pen.0);
         let mut cache = self.outlines.lock().unwrap_or_else(|e| e.into_inner());

crates/text/src/lib.rs

@@ -18,6 +18,8 @@ mod fontdb;
 pub mod hyphen;
 mod layout;
 mod shape;
+#[cfg(any(test, feature = "test-fonts"))]
+pub mod test_fonts;
 pub mod thread;
 
 pub use craft_fonts::{CRAFT_FONTS, CraftFont};
@@ -385,4 +387,6 @@ mod tests_sysfonts;
 #[cfg(test)]
 mod tests_typo;
 #[cfg(test)]
+mod tests_variable;
+#[cfg(test)]
 mod tests_vertical;

crates/text/src/shape.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 
 use harfrust::{Direction, Feature, ShapeOptions, UnicodeBuffer};
 use skrifa::MetadataProvider;
-use skrifa::instance::{LocationRef, Size};
+use skrifa::instance::Size;
 use vectorcraft_doc::CharStyle;
 
 use crate::features::OtFeatures;
@@ -247,7 +247,7 @@ fn shape_segment(text: &str, seg: &Segment, feats: &OtFeatures, out: &mut Vec<SG
 
     let mut raw: Vec<(u32, u32, i32, i32, i32)> = Vec::with_capacity(text_seg.len()); // gid, cluster, xadv, xoff, yoff
     let shaped = face.hb().map(|hb| {
-        let shaper = face.shaper.shaper(&hb).build();
+        let shaper = face.shaper.shaper(&hb).instance(face.instance.as_ref()).build();
         let mut buf = UnicodeBuffer::new();
         for (i, c) in text_seg.char_indices() {
             let cl = (range.start + i) as u32;
@@ -271,7 +271,7 @@ fn shape_segment(text: &str, seg: &Segment, feats: &OtFeatures, out: &mut Vec<SG
         // Fallback: nominal glyphs and hmtx advances, no shaping.
         if let Some(f) = face.skrifa() {
             let cmap = f.charmap();
-            let gm = f.glyph_metrics(Size::unscaled(), LocationRef::default());
+            let gm = f.glyph_metrics(Size::unscaled(), face.location());
             for (i, c) in text_seg.char_indices() {
                 let cl = (range.start + i) as u32;
                 let chars: Vec<char> = if upper { c.to_uppercase().collect() } else { vec![c] };

crates/text/src/test_fonts.rs

@@ -0,0 +1,112 @@
+//! Fonts built in code for tests, so no font file is committed: a small variable font (#296).
+//! Compiled for this crate's tests and, with the `test-fonts` feature, for other crates' tests.
+
+use skrifa::instance::{LocationRef, Size};
+use skrifa::raw::TableProvider;
+use skrifa::raw::tables::glyf::Glyph;
+use skrifa::{GlyphId, MetadataProvider};
+use write_fonts::FontBuilder;
+use write_fonts::tables::fvar::{AxisInstanceArrays, Fvar, InstanceRecord, VariationAxisRecord};
+use write_fonts::tables::gvar::{GlyphDelta, GlyphDeltas, GlyphVariations, Gvar, Tent};
+use write_fonts::types::{F2Dot14, Fixed, NameId, Tag};
+
+/// The family of [`variable_font`].
+pub const VARIABLE_FAMILY: &str = "Varitest Sans";
+
+/// The characters [`variable_font`] widens towards its heaviest weight (simple glyphs in Source Sans
+/// 3; the composite ones, like `H`, would need their components varied).
+pub const VARIABLE_CHARS: &str = "lIn";
+
+/// How much wider [`VARIABLE_CHARS`] are at the heaviest weight (outlines and advances).
+pub const VARIABLE_WIDEN: f32 = 0.25;
+
+/// The bundled Source Sans 3 Regular as a variable font of family [`VARIABLE_FAMILY`]: one weight
+/// axis (400–700, default 400, the face itself being Regular) whose maximum makes the glyphs of
+/// [`VARIABLE_CHARS`] [`VARIABLE_WIDEN`] wider (outlines and advances, through `gvar`), with the
+/// named instances Normal (the default, the face Regular), SemiBold (550) and Bold (700), plus an instance without
+/// a name and one named like another (`BOLD`), which style lists leave out. `None` when it can't
+/// be built.
+pub fn variable_font() -> Option<Vec<u8>> {
+    const BASE: &[u8] = include_bytes!("../../../assets/fonts/SourceSans3-Regular.ttf");
+    let font = skrifa::FontRef::new(BASE).ok()?;
+    let (glyf, loca) = (font.glyf().ok()?, font.loca(None).ok()?);
+    let metrics = font.glyph_metrics(Size::unscaled(), LocationRef::default());
+    let charmap = font.charmap();
+    let widened: Vec<GlyphId> = VARIABLE_CHARS.chars().filter_map(|c| charmap.map(c)).collect();
+    let mut variations = Vec::new();
+    for g in 0..u32::from(font.maxp().ok()?.num_glyphs()) {
+        let gid = write_fonts::types::GlyphId::new(g);
+        let id = GlyphId::new(g);
+        let deltas = if widened.contains(&id) {
+            let Ok(Some(Glyph::Simple(s))) = loca.get_glyf(id, &glyf) else { return None };
+            let wider = |x: f32| (x * VARIABLE_WIDEN).round() as i16;
+            let mut d: Vec<GlyphDelta> = s.points().map(|p| GlyphDelta::required(wider(f32::from(p.x)), 0)).collect();
+            // The phantom points: left side bearing, advance, top, bottom.
+            let advance = wider(metrics.advance_width(id)?);
+            d.extend([(0, 0), (advance, 0), (0, 0), (0, 0)].map(|(x, y)| GlyphDelta::required(x, y)));
+            vec![GlyphDeltas::new(vec![Tent::new(F2Dot14::from_f32(1.0), None)], d)]
+        } else {
+            vec![]
+        };
+        variations.push(GlyphVariations::new(gid, deltas));
+    }
+    let gvar = Gvar::new(variations, 1).ok()?;
+    let axis = VariationAxisRecord {
+        axis_tag: Tag::new(b"wght"),
+        min_value: Fixed::from_i32(400),
+        default_value: Fixed::from_i32(400),
+        max_value: Fixed::from_i32(700),
+        flags: 0,
+        axis_name_id: NameId::new(256),
+    };
+    let instance = |name: u16, wght: i32| InstanceRecord {
+        subfamily_name_id: NameId::new(name),
+        flags: 0,
+        coordinates: vec![Fixed::from_i32(wght)],
+        post_script_name_id: None,
+    };
+    let instances = vec![instance(257, 400), instance(258, 550), instance(259, 700), instance(260, 600), instance(261, 650)];
+    let fvar = Fvar::new(AxisInstanceArrays::new(vec![axis], instances));
+    let name = name_table(&[
+        (1, VARIABLE_FAMILY),
+        (2, "Regular"),
+        (4, "Varitest Sans Regular"),
+        (6, "VaritestSans-Regular"),
+        (256, "Weight"),
+        (257, "Normal"),
+        (258, "SemiBold"),
+        (259, "Bold"),
+        (261, "BOLD"),
+    ])?;
+    let mut builder = FontBuilder::new();
+    builder.add_raw(Tag::new(b"name"), name);
+    builder.add_table(&fvar).ok()?.add_table(&gvar).ok()?;
+    // The rest of Source Sans 3's tables as they are.
+    for r in font.table_directory.table_records() {
+        let tag = Tag::new(&r.tag().to_be_bytes());
+        if !builder.contains(tag) {
+            builder.add_raw(tag, font.table_data(r.tag())?.as_bytes());
+        }
+    }
+    Some(builder.build())
+}
+
+/// A `name` table of Windows English (US) records (name id, string).
+pub fn name_table(records: &[(u16, &str)]) -> Option<Vec<u8>> {
+    let mut records = records.to_vec();
+    records.sort_by_key(|r| r.0);
+    let n = u16::try_from(records.len()).ok()?;
+    let (mut head, mut strings) = (Vec::new(), Vec::new());
+    for v in [0, n, 6 + 12 * n] {
+        head.extend_from_slice(&v.to_be_bytes());
+    }
+    for (id, s) in records {
+        let bytes: Vec<u8> = s.encode_utf16().flat_map(u16::to_be_bytes).collect();
+        for v in [3, 1, 0x0409, id, u16::try_from(bytes.len()).ok()?, u16::try_from(strings.len()).ok()?] {
+            head.extend_from_slice(&v.to_be_bytes());
+        }
+        strings.extend(bytes);
+    }
+    head.extend(strings);
+    Some(head)
+}

crates/text/src/tests_variable.rs

@@ -0,0 +1,248 @@
+//! Variable fonts: each named instance is a style of its own, listed, resolved, shaped, drawn and
+//! embedded at its axis settings (#296: Figtree listed only Light, its default instance).
+
+use kurbo::{Point, Shape};
+use skrifa::MetadataProvider;
+use skrifa::instance::{LocationRef, Size};
+use skrifa::raw::TableProvider;
+use vectorcraft_doc::CharStyle;
+
+use super::test_fonts::{VARIABLE_CHARS, VARIABLE_FAMILY as FAMILY, VARIABLE_WIDEN, name_table, variable_font};
+use super::*;
+
+fn font() -> Vec<u8> {
+    variable_font().expect("the test font builds")
+}
+
+/// A database of the bundled fonts and the test variable font.
+fn db() -> FontDb {
+    let db = FontDb::with_font_dirs(vec![]);
+    assert_eq!(db.add_font(font()), 3, "Regular, SemiBold and Bold");
+    db
+}
+
+/// The width of `c`'s outline in font units.
+fn ink_width(db: &FontDb, face: &FontFace, c: char) -> f64 {
+    db.outline(face, face.glyph_for(c)).bounding_box().width()
+}
+
+fn text(family: &str, style: &str, s: &str) -> TextObject {
+    TextObject::point(Point::ZERO, s, CharStyle { font_family: family.into(), font_style: style.into(), size: 100.0, ..CharStyle::default() })
+}
+
+#[test]
+fn named_instances_are_styles_of_the_family() {
+    let db = db();
+    // The default instance is the face itself; the unnamed and the twice-named ones are left out.
+    assert_eq!(db.styles(FAMILY), ["Regular", "SemiBold", "Bold"]);
+    let bold = db.face(FAMILY, "Bold").unwrap();
+    assert_eq!((bold.family.as_str(), bold.style.as_str(), bold.weight, bold.italic), (FAMILY, "Bold", 700.0, false));
+    assert_eq!(bold.variations(), [(*b"wght", 700.0)]);
+    let regular = db.face(FAMILY, "Regular").unwrap();
+    assert!(regular.variations().is_empty() && regular.weight == 400.0);
+    assert_eq!(db.face(FAMILY, "SemiBold").unwrap().weight, 550.0);
+    // Fonts added again add nothing.
+    assert_eq!(db.add_font(font()), 0);
+}
+
+#[test]
+fn an_instance_is_found_by_its_names_and_by_weight() {
+    let db = db();
+    let m = |f: &str, s: &str| db.resolve(f, s).map(|(face, m)| (face.style.clone(), m)).unwrap();
+    assert_eq!(m(FAMILY, "Bold"), ("Bold".into(), FontMatch::Exact));
+    assert_eq!(m("varitest sans", "semi bold"), ("SemiBold".into(), FontMatch::Exact), "names are normalized");
+    // The default instance's own name names the face.
+    assert_eq!(m(FAMILY, "Normal"), ("Regular".into(), FontMatch::Exact));
+    assert!(!db.styles(FAMILY).contains(&"Normal".to_string()));
+    // A style the font hasn't: the closest weight.
+    assert_eq!(m(FAMILY, "Black"), ("Bold".into(), FontMatch::Style));
+    assert_eq!(m(FAMILY, "Medium"), ("SemiBold".into(), FontMatch::Style));
+    // PostScript names (as PDF and .ai files name fonts): `<family>-<style>` without spaces.
+    assert_eq!(m("VaritestSans-Bold", "Regular"), ("Bold".into(), FontMatch::Exact));
+    assert_eq!(db.find_postscript("VaritestSans-SemiBold").unwrap().style, "SemiBold");
+}
+
+#[test]
+fn an_instance_draws_and_measures_its_own_glyphs() {
+    let db = db();
+    let (regular, semi, bold) = (db.face(FAMILY, "Regular").unwrap(), db.face(FAMILY, "SemiBold").unwrap(), db.face(FAMILY, "Bold").unwrap());
+    let widen = f64::from(VARIABLE_WIDEN);
+    for c in VARIABLE_CHARS.chars() {
+        let g = regular.glyph_for(c);
+        assert_eq!(bold.glyph_for(c), g);
+        // Advances (gvar phantom points) and outlines: a quarter wider at Bold, half that at SemiBold.
+        let (r, b, s) = (regular.advance(g), bold.advance(g), semi.advance(g));
+        assert!((b - r * (1.0 + widen)).abs() <= 1.0, "{c}: advance {r} -> {b}");
+        assert!((s - r * (1.0 + widen / 2.0)).abs() <= 1.0, "{c}: SemiBold advance {s}");
+        let (ri, bi) = (ink_width(&db, &regular, c), ink_width(&db, &bold, c));
+        assert!((bi - ri * (1.0 + widen)).abs() <= 2.0, "{c}: outline {ri} -> {bi}");
+    }
+    // Characters the axis doesn't change stay as they are.
+    let o = regular.glyph_for('o');
+    assert_eq!(regular.advance(o), bold.advance(o));
+    assert_eq!(db.outline(&regular, o).to_svg(), db.outline(&bold, o).to_svg());
+
+    // Laid out (shaped with the instance): the glyphs come from the Bold face, advance as it does
+    // and are drawn with its outlines (what the canvas, Create Outlines and hit tests use).
+    let (lr, lb) = (layout(&db, &text(FAMILY, "Regular", VARIABLE_CHARS)), layout(&db, &text(FAMILY, "Bold", VARIABLE_CHARS)));
+    assert!(lb.glyphs.iter().all(|g| g.font_id == bold.id()));
+    let width = |l: &TextLayout| l.glyphs.iter().map(|g| g.advance).sum::<f64>();
+    let expected: f64 = VARIABLE_CHARS.chars().map(|c| bold.advance(bold.glyph_for(c))).sum::<f64>() * 100.0 / bold.units_per_em();
+    assert!((width(&lb) - expected).abs() < 0.5, "shaped {} vs {expected}", width(&lb));
+    assert!(width(&lb) > width(&lr) * (1.0 + widen * 0.9));
+    let ink = |l: &TextLayout| l.to_bezpath().bounding_box().width();
+    assert!(ink(&lb) > ink(&lr) * (1.0 + widen * 0.9), "{} vs {}", ink(&lb), ink(&lr));
+}
+
+#[test]
+fn an_embedded_instance_is_a_static_font_of_that_instance() {
+    let db = db();
+    let bold = db.face(FAMILY, "Bold").unwrap();
+    let e = bold.embed(&['l', 'o']).unwrap();
+    assert!(e.subset && !e.cff);
+    let f = skrifa::FontRef::new(&e.data).unwrap();
+    assert!(f.fvar().is_err() && f.gvar().is_err(), "no variations left");
+    let g = f.charmap().map('l').unwrap();
+    let adv = f.glyph_metrics(Size::unscaled(), LocationRef::default()).advance_width(g).unwrap();
+    assert!((f64::from(adv) - bold.advance(bold.glyph_for('l'))).abs() <= 1.0, "the Bold advance: {adv}");
+    // The default face embeds as before.
+    let regular = db.face(FAMILY, "Regular").unwrap();
+    let data = regular.embed(&['l']).unwrap().data;
+    let r = skrifa::FontRef::new(&data).unwrap();
+    let rl = r.glyph_metrics(Size::unscaled(), LocationRef::default()).advance_width(r.charmap().map('l').unwrap()).unwrap();
+    assert!((f64::from(rl) - regular.advance(regular.glyph_for('l'))).abs() <= 1.0 && rl < adv, "{rl} vs {adv}");
+}
+
+#[test]
+fn installed_variable_fonts_list_their_instances_before_loading() {
+    let dir = std::env::temp_dir().join(format!("vc-varfonts-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    std::fs::write(dir.join("Varitest[wght].ttf"), font()).unwrap();
+    let db = FontDb::with_font_dirs(vec![dir]);
+    assert_eq!(db.styles(FAMILY), ["Regular", "SemiBold", "Bold"]);
+    assert!(!db.is_loaded(FAMILY), "listed from the name and fvar tables alone");
+    assert_eq!(db.by_postscript_name("VaritestSans-Bold"), Some((FAMILY.to_string(), "Bold".to_string())));
+    let (bold, m) = db.resolve(FAMILY, "Bold").unwrap();
+    assert_eq!((bold.style.as_str(), m), ("Bold", FontMatch::Exact));
+    assert_eq!(bold.variations(), [(*b"wght", 700.0)]);
+    assert!(bold.path().is_some());
+}
+
+/// Damaged or hostile `fvar` tables give fewer styles, never a panic, and the face still works.
+#[test]
+fn damaged_variation_tables_never_panic() {
+    let name = name_table(&[(1, "Broken Var"), (2, "Regular"), (256, "W")]).unwrap();
+    let be = |v: &[u32]| v.iter().flat_map(|x| x.to_be_bytes()).collect::<Vec<u8>>();
+    // Header: version 1.0, axes offset 16, reserved, axis count, axis size 20, instance count,
+    // instance size.
+    let header = |axes: u16, axis_size: u16, instances: u16, instance_size: u16| {
+        let mut h = be(&[0x0001_0000]);
+        for v in [16, 2, axes, axis_size, instances, instance_size] {
+            h.extend(v.to_be_bytes());
+        }
+        h
+    };
+    let axis = |tag: &[u8; 4], min: i32, def: i32, max: i32| {
+        let mut a = tag.to_vec();
+        a.extend(be(&[(min << 16) as u32, (def << 16) as u32, (max << 16) as u32]));
+        a.extend([0, 0, 1, 0]);
+        a
+    };
+    let mut damaged: Vec<Vec<u8>> = vec![
+        vec![],
+        vec![0; 3],
+        header(0xffff, 20, 0xffff, 8),
+        [header(1, 20, 0xffff, 8), axis(b"wght", 100, 400, 900)].concat(),
+        [header(1, 20, 3, 0xffff), axis(b"wght", 100, 400, 900)].concat(),
+        [header(1, 0, 3, 8), axis(b"wght", 100, 400, 900)].concat(),
+        [header(200, 20, 1, 804), vec![0; 4000]].concat(),
+    ];
+    // Many instances (all named): the list is capped.
+    let mut many = [header(1, 20, 2000, 8), axis(b"wght", 0, 0, 30000)].concat();
+    for i in 0..2000u32 {
+        many.extend(be(&[256 << 16, (i + 1) << 16]));
+    }
+    damaged.push(many);
+    for fvar in &damaged {
+        let f = fontdb::sfnt_of(&[(b"name", &name), (b"fvar", fvar)]).unwrap();
+        let styles = fontdb::face_styles(&skrifa::FontRef::new(&f).unwrap());
+        assert!(!styles.is_empty() && styles.len() <= 2, "{} styles", styles.len());
+    }
+    // A real font with a damaged fvar (and its gvar) still loads and lays out.
+    let good = font();
+    let at = |tag: &[u8; 4]| {
+        let tables = u16::from_be_bytes([good[4], good[5]]) as usize;
+        let r = (0..tables).map(|i| 12 + 16 * i).find(|r| &good[*r..*r + 4] == tag).unwrap();
+        let off = u32::from_be_bytes(good[r + 8..r + 12].try_into().unwrap()) as usize;
+        let len = u32::from_be_bytes(good[r + 12..r + 16].try_into().unwrap()) as usize;
+        off..off + len
+    };
+    let (fvar, gvar) = (at(b"fvar"), at(b"gvar"));
+    // Deterministic byte damage across both tables.
+    let mut seed = 0x2545_f491_u32;
+    for round in 0..300 {
+        let mut bad = good.clone();
+        for _ in 0..1 + round % 8 {
+            seed ^= seed << 13;
+            seed ^= seed >> 17;
+            seed ^= seed << 5;
+            let range = if seed.is_multiple_of(2) { fvar.clone() } else { gvar.clone() };
+            let i = range.start + (seed as usize >> 3) % range.len();
+            bad[i] = (seed >> 24) as u8;
+        }
+        let db = FontDb::with_font_dirs(vec![]);
+        db.add_font(bad);
+        for style in db.styles(FAMILY) {
+            let l = layout(&db, &text(FAMILY, &style, "lHio"));
+            assert!(l.glyphs.len() <= 8, "{style}: {} glyphs", l.glyphs.len());
+        }
+    }
+}
+
+/// Windows ships variable system fonts: Bahnschrift (weight and width axes) lists its named
+/// instances and draws them. Skipped where it isn't installed.
+#[test]
+fn bahnschrift_lists_and_draws_its_instances() {
+    let db = FontDb::with_font_dirs(system_font_dirs());
+    if !db.has_family("Bahnschrift") {
+        eprintln!("skipped: Bahnschrift is not installed");
+        return;
+    }
+    let styles = db.styles("Bahnschrift");
+    eprintln!("Bahnschrift: {styles:?}");
+    for s in ["Light", "Regular", "SemiBold", "Bold"] {
+        assert!(styles.iter().any(|x| x == s), "{s} in {styles:?}");
+    }
+    let light = db.face("Bahnschrift", "Light").unwrap();
+    let bold = db.face("Bahnschrift", "Bold").unwrap();
+    assert_eq!((light.style.as_str(), bold.style.as_str()), ("Light", "Bold"));
+    assert!(bold.weight > light.weight, "{} vs {}", bold.weight, light.weight);
+    let (lw, bw) = (ink_width(&db, &light, 'l'), ink_width(&db, &bold, 'l'));
+    assert!(bw > lw * 1.05, "the Bold l is wider: {lw} -> {bw}");
+    let w = |s: &str| layout(&db, &text("Bahnschrift", s, "Hamburgefonstiv")).to_bezpath().bounding_box().width();
+    assert!(w("Bold") > w("Light"), "{} vs {}", w("Bold"), w("Light"));
+}
+
+/// Segoe UI Variable (Windows 11; optical size and weight axes). Skipped where it isn't installed.
+#[test]
+fn segoe_ui_variable_lists_its_instances() {
+    let db = FontDb::with_font_dirs(system_font_dirs());
+    let families: Vec<String> = db.families().into_iter().filter(|f| f.starts_with("Segoe UI Variable")).collect();
+    if families.is_empty() {
+        eprintln!("skipped: Segoe UI Variable is not installed");
+        return;
+    }
+    for f in &families {
+        let styles = db.styles(f);
+        eprintln!("{f}: {styles:?}");
+        assert!(styles.len() > 1, "{f}: {styles:?}");
+    }
+    if families.iter().any(|f| f == "Segoe UI Variable") {
+        let (light, bold) = (db.face("Segoe UI Variable", "Light Text").unwrap(), db.face("Segoe UI Variable", "Bold Text").unwrap());
+        assert_eq!((light.style.as_str(), bold.style.as_str()), ("Light Text", "Bold Text"));
+        assert!(bold.weight > light.weight && !bold.variations().is_empty());
+        let w = |f: &FontFace| ink_width(&db, f, 'm');
+        assert!(w(&bold) > w(&light), "{} vs {}", w(&bold), w(&light));
+    }
+}

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/dock.rs

@@ -1,109 +1,200 @@
 //! The right dock: Properties | Layers | Libraries tabs, plus the collapsed icon-panel column
-//! whose panels pop out to the left.
+//! whose panels pop out to the left. The double arrow at the top of the dock collapses the tabbed
+//! group to icons at the top of the icon column (`window.collapseDock`); the arrow above the column
+//! then expands it again.
 
-use egui::{CornerRadius, Sense, Stroke, Ui, vec2};
+use egui::{CornerRadius, Rect, Sense, Stroke, Ui, vec2};
+use serde_json::json;
 
 use crate::state::{DockTab, ICON_PANEL_GROUPS, ICON_PANELS};
 use crate::theme::{self, Tokens};
 use crate::{VectorcraftApp, icons, panels, widgets};
 
 const ICON_COL: f32 = 38.0;
+/// Height of the strip along the top of a dock column that carries its double arrow.
+const HEADER: f32 = 14.0;
+/// The tabbed group's width until the dock has been laid out (its default size).
+const DOCK_WIDTH: f32 = 300.0;
+/// Top of a popped-out panel.
+const FLYOUT_TOP: f32 = 110.0;
+
+/// Where the icon column's left edge was drawn last (egui temp memory, one frame old).
+fn column_left_id() -> egui::Id {
+    egui::Id::new("dock-icon-column-left")
+}
+
+/// Collapse the tabbed group to icons or expand it again (`window.collapseDock`). Expanding while
+/// one of its panels is popped out shows that panel's tab instead.
+pub fn set_collapsed(app: &mut VectorcraftApp, collapsed: bool) {
+    app.ui.dock_collapsed = collapsed;
+    app.ui.dock = true;
+    if !collapsed && let Some(tab) = app.ui.open_panel.as_deref().and_then(DockTab::from_id) {
+        app.ui.dock_tab = tab;
+        app.ui.open_panel = None;
+    }
+}
+
+/// The strip along the top of a dock column with its double arrow: » collapses the dock to icons,
+/// « expands it. The whole strip is the click target (as on the toolbar). True when clicked.
+fn collapse_header(ui: &mut Ui, collapsed: bool) -> bool {
+    let t = Tokens::get(ui.ctx());
+    let (hdr, resp) = ui.allocate_exact_size(vec2(ui.available_width(), HEADER), Sense::click());
+    ui.painter().rect_filled(hdr, 0.0, t.tab_strip);
+    let arrow = Rect::from_min_size(hdr.right_top() + vec2(-16.0, 1.0), vec2(12.0, 12.0));
+    if resp.hovered() {
+        ui.painter().rect_filled(arrow, CornerRadius::same(2), t.hover);
+    }
+    let icon = if collapsed { "chevrons-left" } else { "chevrons-right" };
+    icons::paint(ui, icon, arrow.shrink(1.0), if resp.hovered() { t.text_strong } else { t.text });
+    resp.on_hover_text(if collapsed { tl!("Expand Panels") } else { tl!("Collapse to Icons") }).clicked()
+}
+
+/// Run `window.collapseDock` for a click on a double arrow.
+fn toggle(app: &mut VectorcraftApp, collapsed: bool) {
+    // It only fails on bad params, which this never sends; show it all the same.
+    if let Err(e) = app.run("window.collapseDock", json!({ "collapsed": collapsed })) {
+        app.ui.status = e;
+    }
+}
+
+/// One icon of the column: a click pops its panel out (or puts it away).
+fn panel_icon(app: &mut VectorcraftApp, ui: &mut Ui, id: &str, label: &str, icon: &str) {
+    let open = app.ui.open_panel.as_deref() == Some(id);
+    if widgets::icon_button(ui, icon, label, open, 30.0).clicked() {
+        app.ui.open_panel = if open { None } else { Some(id.to_string()) };
+    }
+}
 
 pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
     let t = Tokens::get(ui.ctx());
-    // Main tabbed group.
-    egui::Panel::right("dock")
-        .resizable(true)
-        .default_size(300.0)
-        .size_range(230.0..=520.0)
-        .frame(egui::Frame::NONE.fill(t.panel).stroke(Stroke::new(1.5, t.border)))
-        .show(ui, |ui| {
-            // Tab strip.
-            let (hdr, _) = ui.allocate_exact_size(vec2(ui.available_width(), 14.0), Sense::hover());
-            ui.painter().rect_filled(hdr, 0.0, t.tab_strip);
-            icons::paint(ui, "chevrons-right", egui::Rect::from_min_size(hdr.right_top() + vec2(-14.0, 2.0), vec2(10.0, 10.0)), t.text);
-            let (strip, _) = ui.allocate_exact_size(vec2(ui.available_width(), 33.0), Sense::hover());
-            ui.painter().rect_filled(strip, 0.0, t.tab_strip);
-            ui.painter().line_segment([strip.left_bottom(), strip.right_bottom()], Stroke::new(1.0, t.border));
-            let mut x = strip.left();
-            for (tab, label) in [(DockTab::Properties, "Properties"), (DockTab::Layers, "Layers"), (DockTab::Libraries, "Libraries")] {
-                let active = app.ui.dock_tab == tab;
-                let galley =
-                    ui.painter().layout_no_wrap(tl!(label).to_string(), theme::semibold(12.5), if active { t.text_strong } else { t.text_dim });
-                let r = egui::Rect::from_min_size(egui::pos2(x, strip.top()), vec2(galley.size().x + 24.0, strip.height() - 1.0));
-                let resp = ui.interact(r, ui.id().with(("docktab", label)), Sense::click());
-                if active {
-                    ui.painter().rect_filled(r, 0.0, t.panel);
+    // Main tabbed group, unless it is collapsed to icons.
+    if !app.ui.dock_collapsed {
+        egui::Panel::right("dock")
+            .resizable(true)
+            .default_size(DOCK_WIDTH)
+            .size_range(230.0..=520.0)
+            .frame(egui::Frame::NONE.fill(t.panel).stroke(Stroke::new(1.5, t.border)))
+            .show(ui, |ui| {
+                if collapse_header(ui, false) {
+                    toggle(app, true);
                 }
-                ui.painter().galley(egui::pos2(r.left() + 12.0, r.center().y - galley.size().y / 2.0), galley, t.text);
-                ui.painter().line_segment([r.right_top(), r.right_bottom()], Stroke::new(1.0, t.border));
-                if resp.clicked() {
-                    app.ui.dock_tab = tab;
+                // Tab strip.
+                let (strip, _) = ui.allocate_exact_size(vec2(ui.available_width(), 33.0), Sense::hover());
+                ui.painter().rect_filled(strip, 0.0, t.tab_strip);
+                ui.painter().line_segment([strip.left_bottom(), strip.right_bottom()], Stroke::new(1.0, t.border));
+                let mut x = strip.left();
+                for tab in DockTab::ALL {
+                    let (_, label, _) = tab.info();
+                    let active = app.ui.dock_tab == tab;
+                    let galley =
+                        ui.painter().layout_no_wrap(tl!(label).to_string(), theme::semibold(12.5), if active { t.text_strong } else { t.text_dim });
+                    let r = egui::Rect::from_min_size(egui::pos2(x, strip.top()), vec2(galley.size().x + 24.0, strip.height() - 1.0));
+                    let resp = ui.interact(r, ui.id().with(("docktab", label)), Sense::click());
+                    if active {
+                        ui.painter().rect_filled(r, 0.0, t.panel);
+                    }
+                    ui.painter().galley(egui::pos2(r.left() + 12.0, r.center().y - galley.size().y / 2.0), galley, t.text);
+                    ui.painter().line_segment([r.right_top(), r.right_bottom()], Stroke::new(1.0, t.border));
+                    if resp.clicked() {
+                        app.ui.dock_tab = tab;
+                    }
+                    x = r.right();
                 }
-                x = r.right();
-            }
-            let menu_id = match app.ui.dock_tab {
-                DockTab::Properties => "properties",
-                DockTab::Layers => "layers",
-                DockTab::Libraries => "libraries",
-            };
-            panels::panel_menu(app, ui, menu_id, egui::Rect::from_center_size(strip.right_center() - vec2(14.0, 0.0), vec2(16.0, 16.0)));
-            egui::Frame::NONE.inner_margin(egui::Margin { left: 12, right: 10, top: 10, bottom: 8 }).show(ui, |ui| match app.ui.dock_tab {
-                DockTab::Properties => {
-                    egui::ScrollArea::vertical().id_salt("props").auto_shrink([false, false]).show(ui, |ui| panels::properties::show(app, ui));
-                }
-                DockTab::Layers => panels::layers::show(app, ui),
-                DockTab::Libraries => panels::libraries(app, ui),
+                let menu_id = app.ui.dock_tab.info().0;
+                panels::panel_menu(app, ui, menu_id, egui::Rect::from_center_size(strip.right_center() - vec2(14.0, 0.0), vec2(16.0, 16.0)));
+                egui::Frame::NONE.inner_margin(egui::Margin { left: 12, right: 10, top: 10, bottom: 8 }).show(ui, |ui| match app.ui.dock_tab {
+                    DockTab::Properties => {
+                        egui::ScrollArea::vertical().id_salt("props").auto_shrink([false, false]).show(ui, |ui| panels::properties::show(app, ui));
+                    }
+                    DockTab::Layers => panels::layers::show(app, ui),
+                    DockTab::Libraries => panels::libraries(app, ui),
+                });
             });
-        });
-    // Collapsed icon-panel strip, left of the expanded panel group (like Illustrator's dock).
-    egui::Panel::right("icon_column")
+    }
+    // Collapsed icon-panel strip, left of the expanded panel group (like Illustrator's dock). A
+    // collapsed group's panels head it, under the « that expands them again.
+    let collapsed = app.ui.dock_collapsed;
+    let column = egui::Panel::right("icon_column")
         .resizable(false)
         .exact_size(ICON_COL)
-        .frame(egui::Frame::NONE.fill(t.panel).inner_margin(egui::Margin::symmetric(4, 6)).stroke(Stroke::new(1.5, t.border)))
+        .frame(egui::Frame::NONE.fill(t.panel).stroke(Stroke::new(1.5, t.border)))
         .show(ui, |ui| {
-            ui.spacing_mut().item_spacing.y = 2.0;
-            // The icons scroll in a window too short for them.
-            widgets::strip_scroll(ui, "icon_column", |ui| {
-                for (gi, group) in ICON_PANEL_GROUPS.iter().enumerate() {
-                    if gi > 0 {
-                        let (r, _) = ui.allocate_exact_size(vec2(ui.available_width(), 7.0), Sense::hover());
-                        ui.painter().line_segment([r.left_center() + vec2(4.0, 0.0), r.right_center() - vec2(4.0, 0.0)], Stroke::new(1.0, t.divider));
-                    }
-                    for id in group.iter() {
-                        let Some((_, label, icon)) = ICON_PANELS.iter().find(|p| p.0 == *id) else { continue };
-                        let open = app.ui.open_panel.as_deref() == Some(*id);
-                        if widgets::icon_button(ui, icon, label, open, 30.0).clicked() {
-                            app.ui.open_panel = if open { None } else { Some(id.to_string()) };
+            if collapsed && collapse_header(ui, true) {
+                toggle(app, false);
+            }
+            egui::Frame::NONE.inner_margin(egui::Margin::symmetric(4, 6)).show(ui, |ui| {
+                ui.spacing_mut().item_spacing.y = 2.0;
+                // The icons scroll in a window too short for them.
+                widgets::strip_scroll(ui, "icon_column", |ui| {
+                    if collapsed {
+                        for tab in DockTab::ALL {
+                            let (id, label, icon) = tab.info();
+                            panel_icon(app, ui, id, label, icon);
                         }
                     }
-                }
+                    for (gi, group) in ICON_PANEL_GROUPS.iter().enumerate() {
+                        if gi > 0 || collapsed {
+                            let (r, _) = ui.allocate_exact_size(vec2(ui.available_width(), 7.0), Sense::hover());
+                            ui.painter()
+                                .line_segment([r.left_center() + vec2(4.0, 0.0), r.right_center() - vec2(4.0, 0.0)], Stroke::new(1.0, t.divider));
+                        }
+                        for id in group.iter() {
+                            let Some((_, label, icon)) = ICON_PANELS.iter().find(|p| p.0 == *id) else { continue };
+                            panel_icon(app, ui, id, label, icon);
+                        }
+                    }
+                });
             });
         });
+    let left = column.response.rect.left();
+    ui.ctx().data_mut(|d| d.insert_temp(column_left_id(), left));
 }
 
-/// An icon panel popped out next to the icon column.
+/// A panel popped out next to the icon column: an icon panel, or one of the tabbed group's panels
+/// while the dock is collapsed.
 pub fn floating_panel(app: &mut VectorcraftApp, ctx: &egui::Context) {
     let Some(id) = app.ui.open_panel.clone() else { return };
-    let Some((_, label, _)) = ICON_PANELS.iter().find(|p| p.0 == id) else { return };
+    let tab = DockTab::from_id(&id);
+    let label = match tab {
+        Some(tab) if app.ui.dock_collapsed => tab.info().1,
+        // Expanded, the group shows its panels in the dock itself.
+        Some(_) => return,
+        None => match ICON_PANELS.iter().find(|p| p.0 == id) {
+            Some((_, label, _)) => *label,
+            None => return,
+        },
+    };
     let t = Tokens::get(ctx);
     let screen = ctx.content_rect();
-    // Pinned by its right edge, 6 points left of the icon column: a panel wider than its 256
-    // points grows towards the canvas rather than over the panel icons.
-    let right = screen.right() - ICON_COL - 300.0 - 6.0;
+    // Pinned by its right edge, 6 points left of the icon column wherever the dock's width (or its
+    // collapsed state) put it: content wider than the flyout grows it towards the canvas rather
+    // than over the panel icons. Without a dock on screen it keeps to the window's right edge.
+    let column = if app.ui.dock && app.ui.screen_mode < 3 {
+        ctx.data(|d| d.get_temp::<f32>(column_left_id()))
+            .filter(|x| x.is_finite() && *x > screen.left() && *x <= screen.right())
+            .unwrap_or_else(|| screen.right() - ICON_COL - if app.ui.dock_collapsed { 0.0 } else { DOCK_WIDTH })
+    } else {
+        screen.right()
+    };
+    let right = column - 6.0;
+    // The tabbed group's panels fill their height (Layers) or scroll (Properties): give them one
+    // that keeps the flyout on screen.
+    // The tabbed group's panels keep the width the dock gives them; icon panels are 256 points.
+    let width = if tab.is_some() { DOCK_WIDTH } else { 256.0 };
+    let tall = (screen.height() - FLYOUT_TOP - 26.0 - 20.0 - 40.0).clamp(160.0, 560.0);
     let mut open = true;
     let area = egui::Area::new(egui::Id::new("icon-panel")).order(egui::Order::Foreground).pivot(egui::Align2::RIGHT_TOP);
-    area.fixed_pos(egui::pos2(right, 110.0)).show(ctx, |ui| {
+    area.fixed_pos(egui::pos2(right, FLYOUT_TOP)).show(ctx, |ui| {
         egui::Frame::popup(ui.style()).fill(t.panel).corner_radius(CornerRadius::same(4)).inner_margin(egui::Margin::ZERO).show(ui, |ui| {
-            ui.set_width(256.0);
-            let (strip, _) = ui.allocate_exact_size(vec2(256.0, 26.0), Sense::hover());
+            ui.set_width(width);
+            let (strip, _) = ui.allocate_exact_size(vec2(width, 26.0), Sense::hover());
             ui.painter().rect_filled(strip, CornerRadius { nw: 4, ne: 4, sw: 0, se: 0 }, t.panel_darker);
-            let tab = egui::Rect::from_min_size(
+            let title = egui::Rect::from_min_size(
                 strip.min,
                 vec2(ui.painter().layout_no_wrap(tl!(label).to_string(), theme::semibold(12.0), t.text).size().x + 24.0, 26.0),
             );
-            ui.painter().rect_filled(tab, CornerRadius { nw: 4, ne: 0, sw: 0, se: 0 }, t.panel);
-            ui.painter().text(tab.left_center() + vec2(12.0, 0.0), egui::Align2::LEFT_CENTER, tl!(label), theme::semibold(12.0), t.text);
+            ui.painter().rect_filled(title, CornerRadius { nw: 4, ne: 0, sw: 0, se: 0 }, t.panel);
+            ui.painter().text(title.left_center() + vec2(12.0, 0.0), egui::Align2::LEFT_CENTER, tl!(label), theme::semibold(12.0), t.text);
             let close = egui::Rect::from_center_size(strip.right_center() - vec2(13.0, 0.0), vec2(14.0, 14.0));
             let cr = ui.interact(close, ui.id().with("close-panel"), Sense::click());
             icons::paint(ui, "chevrons-right", close, if cr.hovered() { t.text } else { t.text_dim });
@@ -113,8 +204,26 @@ pub fn floating_panel(app: &mut VectorcraftApp, ctx: &egui::Context) {
             let menu_r = egui::Rect::from_center_size(strip.right_center() - vec2(34.0, 0.0), vec2(16.0, 16.0));
             panels::panel_menu(app, ui, &id, menu_r);
             egui::Frame::NONE.inner_margin(egui::Margin::same(10)).show(ui, |ui| {
-                ui.set_width(236.0);
-                panels::show_icon_panel(app, ui, &id);
+                ui.set_width(width - 20.0);
+                match tab {
+                    Some(DockTab::Properties) => {
+                        // At least `tall` when the sections are taller: the flyout's area keeps the
+                        // size its content needs, and egui sizes a new area at most 400 points high,
+                        // so a scroll area that only took the room it was given never grew past it.
+                        egui::ScrollArea::vertical()
+                            .id_salt("props-flyout")
+                            .max_height(tall)
+                            .min_scrolled_height(tall)
+                            .auto_shrink([false, true])
+                            .show(ui, |ui| panels::properties::show(app, ui));
+                    }
+                    Some(DockTab::Layers) => {
+                        ui.set_max_height(tall);
+                        panels::layers::show(app, ui);
+                    }
+                    Some(DockTab::Libraries) => panels::libraries(app, ui),
+                    None => panels::show_icon_panel(app, ui, &id),
+                }
             });
         });
     });
@@ -179,4 +288,157 @@ mod tests {
         }
         assert!(icons.last().unwrap().bottom() <= 400.0, "scrolled into view: {:?}", icons.last());
     }
+
+    const SCREEN: egui::Vec2 = vec2(1600.0, 1000.0);
+
+    /// A frame of the dock and its flyout on a 1600 × 1000 window.
+    struct Harness {
+        app: VectorcraftApp,
+        ctx: egui::Context,
+        time: f64,
+    }
+
+    impl Harness {
+        fn new() -> Self {
+            let mut app = VectorcraftApp::new(Session::new(), Default::default());
+            app.run("file.new", json!({"width": 300, "height": 300})).unwrap();
+            app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 40})).unwrap();
+            let ctx = egui::Context::default();
+            theme::install_fonts(&ctx);
+            let mut h = Self { app, ctx, time: 0.0 };
+            h.settle();
+            h
+        }
+
+        fn frame(&mut self, events: Vec<egui::Event>) {
+            self.time += 0.05;
+            let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, SCREEN);
+            let input = egui::RawInput { time: Some(self.time), events, screen_rect: Some(screen), ..Default::default() };
+            let app = &mut self.app;
+            self.ctx
+                .run_ui(input, |ui| {
+                    show(app, ui);
+                    floating_panel(app, ui.ctx());
+                })
+                .textures_delta
+                .clear();
+        }
+
+        fn settle(&mut self) {
+            for _ in 0..3 {
+                self.frame(vec![]);
+            }
+        }
+
+        fn click(&mut self, at: egui::Pos2) {
+            let button =
+                |pressed| egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
+            self.frame(vec![egui::Event::PointerMoved(at), button(true)]);
+            self.frame(vec![button(false)]);
+            self.settle();
+        }
+
+        /// The icon column's left edge as last drawn.
+        fn column_left(&self) -> f32 {
+            self.ctx.data(|d| d.get_temp::<f32>(column_left_id())).unwrap()
+        }
+
+        /// The panel icons of the column, top to bottom.
+        fn icons(&self) -> Vec<Rect> {
+            widget_rects(&self.ctx, vec2(30.0, 30.0))
+        }
+
+        /// The double arrow at the top right of the window (the dock's, or the collapsed column's).
+        fn arrow(&self) -> egui::Pos2 {
+            egui::pos2(SCREEN.x - 10.0, HEADER / 2.0)
+        }
+    }
+
+    fn icon_panel_count() -> usize {
+        ICON_PANEL_GROUPS.iter().map(|g| g.len()).sum()
+    }
+
+    #[test]
+    fn the_double_arrow_collapses_the_dock_to_icons_and_back() {
+        let mut h = Harness::new();
+        assert!(!h.app.ui.dock_collapsed);
+        // Expanded, the group (at least its 230-point minimum) is right of the column.
+        let expanded = |left: f32| left <= SCREEN.x - ICON_COL - 230.0;
+        assert!(expanded(h.column_left()), "expanded: the group is right of the column: {}", h.column_left());
+        assert_eq!(h.icons().len(), icon_panel_count());
+        h.click(h.arrow());
+        assert!(h.app.ui.dock_collapsed, "the » collapses the dock");
+        assert!(h.column_left() > SCREEN.x - ICON_COL - 2.0, "collapsed: only the icon column is left: {}", h.column_left());
+        let icons = h.icons();
+        assert_eq!(icons.len(), icon_panel_count() + 3, "Properties, Layers and Libraries became icons");
+        assert!(icons[0].top() > HEADER, "the icons sit under the « strip");
+        h.click(h.arrow());
+        assert!(!h.app.ui.dock_collapsed, "the « expands the dock again");
+        assert!(expanded(h.column_left()), "the group is back: {}", h.column_left());
+        assert_eq!(h.icons().len(), icon_panel_count());
+    }
+
+    #[test]
+    fn a_collapsed_panel_pops_out_left_of_the_column() {
+        let mut h = Harness::new();
+        h.app.run("window.collapseDock", json!({"collapsed": true})).unwrap();
+        h.settle();
+        // Properties, Layers, Libraries head the column.
+        let layers = h.icons()[1];
+        h.click(layers.center());
+        assert_eq!(h.app.ui.open_panel.as_deref(), Some("layers"));
+        h.settle();
+        let rect = h.ctx.memory(|m| m.area_rect(egui::Id::new("icon-panel"))).unwrap();
+        let column = h.column_left();
+        assert!(rect.right() <= column, "the flyout {rect:?} stays left of the column at {column}");
+        assert!(rect.left() >= 0.0 && rect.bottom() <= SCREEN.y, "the flyout {rect:?} is on screen");
+        assert!(rect.height() > 200.0, "Layers gets room for its list: {rect:?}");
+        // Its » puts it away.
+        h.click(egui::pos2(rect.right() - 13.0, rect.top() + 13.0));
+        assert_eq!(h.app.ui.open_panel, None, "the flyout's » closes it");
+        // Expanding with a panel popped out shows its tab.
+        h.click(layers.center());
+        assert_eq!(h.app.ui.open_panel.as_deref(), Some("layers"));
+        h.click(h.arrow());
+        assert!(!h.app.ui.dock_collapsed);
+        assert_eq!((h.app.ui.open_panel.as_deref(), h.app.ui.dock_tab), (None, DockTab::Layers));
+        // Properties pops out as wide as the dock and shows its sections, not a sliver, also as
+        // the first flyout of a session (a fresh harness: the flyouts share one area, which
+        // would otherwise keep the size the Layers flyout gave it).
+        let mut h = Harness::new();
+        h.app.run("window.collapseDock", json!({"collapsed": true})).unwrap();
+        h.app.run("window.panel", json!({"panel": "properties"})).unwrap();
+        h.settle();
+        let rect = h.ctx.memory(|m| m.area_rect(egui::Id::new("icon-panel"))).unwrap();
+        assert!(rect.width() >= DOCK_WIDTH && rect.right() <= h.column_left(), "Properties flyout {rect:?}");
+        // Taller than the 400 points egui sizes a new area at: its sections (Align, Quick
+        // Actions) aren't cut off below Appearance.
+        assert!(rect.height() > 450.0 && rect.bottom() <= SCREEN.y, "Properties flyout {rect:?}");
+    }
+
+    #[test]
+    fn the_collapse_command_sets_or_toggles_the_dock() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        assert_eq!(app.run("window.collapseDock", json!({})).unwrap(), json!(true));
+        assert!(app.ui.dock_collapsed && crate::menus::checked(&app, "window.collapseDock", &json!({})) == Some(true));
+        assert_eq!(app.run("window.collapseDock", json!({"collapsed": true})).unwrap(), json!(true));
+        assert!(app.run("window.collapseDock", json!({"collapsed": "yes"})).is_err());
+        // Window › Layers pops Layers out of its icon while collapsed.
+        app.run("window.panel", json!({"panel": "layers"})).unwrap();
+        assert_eq!(app.ui.open_panel.as_deref(), Some("layers"));
+        assert_eq!(crate::menus::checked(&app, "window.panel", &json!({"panel": "layers"})), Some(true));
+        assert_eq!(app.run("window.collapseDock", json!({})).unwrap(), json!(false));
+        assert_eq!((app.ui.open_panel.as_deref(), app.ui.dock_tab), (None, DockTab::Layers));
+        app.run("window.panel", json!({"panel": "properties"})).unwrap();
+        assert_eq!((app.ui.open_panel.as_deref(), app.ui.dock_tab), (None, DockTab::Properties));
+        // Saved with the preferences and with a user workspace; the built-in ones expand it.
+        app.run("window.collapseDock", json!({"collapsed": true})).unwrap();
+        let saved: crate::UiState = serde_json::from_slice(&serde_json::to_vec(&app.ui).unwrap()).unwrap();
+        assert!(saved.sanitized().dock_collapsed);
+        app.run("window.workspace.new", json!({"name": "Icons"})).unwrap();
+        app.run("window.workspace", json!({"name": "Essentials"})).unwrap();
+        assert!(!app.ui.dock_collapsed, "Essentials shows the panels");
+        app.run("window.workspace", json!({"name": "Icons"})).unwrap();
+        assert!(app.ui.dock_collapsed, "the user workspace keeps them collapsed");
+    }
 }

crates/ui-egui/src/i18n/cs.tsv

@@ -569,3 +569,6 @@
 	Make Compound Path	Vytvořit složenou cestu
 	Release Compound Path	Uvolnit složenou cestu
 	Select All	Vybrat vše
+	Collapse Panels to Icons	Sbalit panely na ikony
+	Collapse to Icons	Sbalit na ikony
+	Expand Panels	Rozbalit panely

crates/ui-egui/src/i18n/ja.tsv

@@ -569,3 +569,6 @@
 	Make Compound Path	複合パスを作成
 	Release Compound Path	複合パスを解除
 	Select All	すべてを選択
+	Collapse Panels to Icons	パネルをアイコンに折りたたむ
+	Collapse to Icons	アイコンに折りたたむ
+	Expand Panels	パネルを展開

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	套用效果
@@ -361,6 +362,8 @@
 	CMYK	CMYK
 	CMYK Color	CMYK 色彩
 	CMYK colours print with their own values; off, they go through the colour settings too.	CMYK 顏色以其本身的數值列印；關閉時，也會經過色彩設定處理。
+	Collapse Panels to Icons	將面板收合為圖示
+	Collapse to Icons	收合為圖示
 	Collate	逐份列印
 	Collect for Export	收集以供匯出
 	Collect in New Layer	收集至新圖層
@@ -815,6 +818,7 @@
 	Expand Gradient Mesh	展開漸層網格
 	Expand Gradient To	展開漸層為
 	Expand Options	展開選項
+	Expand Panels	展開面板
 	Expand Repeat	展開重複
 	Expand Shape	展開形狀
 	Expand:	展開：
@@ -1017,6 +1021,8 @@
 	Graphic Styles	繪圖樣式
 	Graphic Styles Options	繪圖樣式選項
 	Graphics	圖形
+	Graphics Processor	圖形處理器
+	Graphics: {adapter}	圖形：{adapter}
 	Gravity	重力
 	Grays	灰色
 	Grays and Neutrals	灰色與中性色
@@ -1073,6 +1079,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 +1782,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/menus.rs

@@ -172,6 +172,12 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
     ("window.taskBar", "Contextual Task Bar", "", "{}"),
     ("window.dock", "Panels", "Tab", "{} show/hide all panels"),
     ("window.panel", "Show Panel", "", "{panel: id} e.g. layers, swatches, stroke (case-insensitive; display labels like \"Layers\" work too)"),
+    (
+        "window.collapseDock",
+        "Collapse Panels to Icons",
+        "",
+        "{collapsed?: bool} collapse the dock's Properties | Layers | Libraries group to icons (true), expand it (false) or toggle (omitted), as the double arrow at the top of the dock does; returns the new state",
+    ),
     ("window.brightness", "UI Brightness", "", "{brightness: dark|mediumDark|mediumLight|light}"),
     ("window.workspace", "Workspace", "", "{name} switch workspace (Essentials, Essentials Classic, Painting, …)"),
     ("window.workspace.reset", "Reset Essentials", "", "{} reset the current workspace"),
@@ -917,27 +923,39 @@ pub fn run_ui_command(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<R
             app.ui.control_bar = on;
             Ok(json!(on))
         }
+        "window.collapseDock" => {
+            let collapsed = match p.get("collapsed") {
+                None | Some(Value::Null) => !app.ui.dock_collapsed,
+                Some(Value::Bool(b)) => *b,
+                Some(_) => return Some(Err("collapsed must be true or false".into())),
+            };
+            crate::dock::set_collapsed(app, collapsed);
+            Ok(json!(collapsed))
+        }
         "window.panel" => {
             let raw = s("panel").unwrap_or_default();
-            match normalize_panel(&raw) {
-                Some("properties") => {
-                    app.ui.dock_tab = DockTab::Properties;
-                    Ok(Value::Null)
-                }
-                Some("layers") => {
-                    app.ui.dock_tab = DockTab::Layers;
-                    Ok(Value::Null)
-                }
-                Some("libraries") => {
-                    app.ui.dock_tab = DockTab::Libraries;
-                    Ok(Value::Null)
-                }
-                Some(p) => {
+            // Canonical id (case-insensitive; display labels work too), then the
+            // dock tab it names, if any.
+            let canonical = normalize_panel(&raw);
+            let tab = canonical.and_then(DockTab::from_id);
+            match (canonical, tab) {
+                // A collapsed dock pops the panel out of its icon, like the icon panels.
+                (Some(p), Some(tab)) if app.ui.dock_collapsed => {
+                    app.ui.dock_tab = tab;
                     app.ui.open_panel = if app.ui.open_panel.as_deref() == Some(p) { None } else { Some(p.to_string()) };
                     app.ui.dock = true;
                     Ok(json!({"open": app.ui.open_panel}))
                 }
-                None => Err(format!("unknown panel `{raw}`")),
+                (Some(_), Some(tab)) => {
+                    app.ui.dock_tab = tab;
+                    Ok(Value::Null)
+                }
+                (Some(p), None) => {
+                    app.ui.open_panel = if app.ui.open_panel.as_deref() == Some(p) { None } else { Some(p.to_string()) };
+                    app.ui.dock = true;
+                    Ok(json!({"open": app.ui.open_panel}))
+                }
+                (None, _) => Err(format!("unknown panel `{raw}`")),
             }
         }
         "window.brightness" => match s("brightness").as_deref().and_then(Brightness::parse) {
@@ -1217,14 +1235,13 @@ pub fn checked(app: &VectorcraftApp, id: &str, p: &Value) -> Option<bool> {
         "window.taskBar" => app.ui.task_bar,
         "window.panel" => {
             let panel = p.get("panel").and_then(Value::as_str).unwrap_or("");
-            match normalize_panel(panel) {
-                Some("properties") => app.ui.dock_tab == DockTab::Properties,
-                Some("layers") => app.ui.dock_tab == DockTab::Layers,
-                Some("libraries") => app.ui.dock_tab == DockTab::Libraries,
-                Some(id) => app.ui.open_panel.as_deref() == Some(id),
-                None => false,
+            let canonical = normalize_panel(panel);
+            match canonical.and_then(DockTab::from_id) {
+                Some(tab) if !app.ui.dock_collapsed => app.ui.dock_tab == tab,
+                _ => canonical.is_some_and(|id| app.ui.open_panel.as_deref() == Some(id)),
             }
         }
+        "window.collapseDock" => app.ui.dock_collapsed,
         "window.workspace" => p.get("name").and_then(Value::as_str) == Some(app.ui.workspace.as_str()),
         "window.brightness" => p.get("brightness").and_then(Value::as_str).and_then(Brightness::parse) == Some(app.ui.brightness),
         "view.slices.lock" => app.session.slices_locked(),
@@ -3166,6 +3183,12 @@ mod tests {
         assert_eq!(app.ui.open_panel.as_deref(), Some("swatches"));
         assert!(checked(&app, "window.panel", &json!({"panel": "Swatches"})).unwrap());
         assert!(app.run("window.panel", json!({"panel": "nope"})).is_err());
+        // A collapsed dock pops the panel out of its icon, by canonical id.
+        app.ui.dock_collapsed = true;
+        app.run("window.panel", json!({"panel": "Layers"})).unwrap();
+        assert_eq!(app.ui.open_panel.as_deref(), Some("layers"));
+        assert!(checked(&app, "window.panel", &json!({"panel": "Layers"})).unwrap());
+        app.ui.dock_collapsed = false;
     }
 
     #[test]

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 {

crates/ui-egui/src/state.rs

@@ -76,6 +76,24 @@ pub enum DockTab {
     Libraries,
 }
 
+impl DockTab {
+    /// The tab's panel id (`window.panel`), English label and icon (when the dock is collapsed).
+    pub fn info(self) -> (&'static str, &'static str, &'static str) {
+        match self {
+            DockTab::Properties => ("properties", "Properties", "dc-options"),
+            DockTab::Layers => ("layers", "Layers", "layers"),
+            DockTab::Libraries => ("libraries", "Libraries", "library"),
+        }
+    }
+
+    pub const ALL: [DockTab; 3] = [DockTab::Properties, DockTab::Layers, DockTab::Libraries];
+
+    /// The tab whose panel id is `id`.
+    pub fn from_id(id: &str) -> Option<DockTab> {
+        DockTab::ALL.into_iter().find(|t| t.info().0 == id)
+    }
+}
+
 /// Panels that live as collapsed icons in the dock (Essentials Classic).
 pub const ICON_PANELS: &[(&str, &str, &str)] = &[
     ("color", "Color", "palette"),
@@ -219,7 +237,12 @@ pub struct UiState {
     pub legacy_language: Option<String>,
     pub brightness: Brightness,
     pub dock_tab: DockTab,
-    /// Icon panel currently popped out of the collapsed column.
+    /// The dock's tabbed group (Properties | Layers | Libraries) is collapsed to icons at the top of
+    /// the icon column (the dock's double arrow, `window.collapseDock`).
+    #[serde(default)]
+    pub dock_collapsed: bool,
+    /// Icon panel currently popped out of the collapsed column (also `properties`, `layers` or
+    /// `libraries` while the dock is collapsed).
     pub open_panel: Option<String>,
     pub control_bar: bool,
     pub toolbar: bool,
@@ -358,6 +381,7 @@ impl Default for UiState {
             legacy_language: None,
             brightness: Brightness::MediumDark,
             dock_tab: DockTab::Properties,
+            dock_collapsed: false,
             open_panel: None,
             control_bar: false,
             toolbar: true,

crates/ui-egui/src/workspaces.rs

@@ -23,6 +23,8 @@ pub struct Workspace {
     pub task_bar: bool,
     pub dock: bool,
     pub dock_tab: DockTab,
+    /// The dock's tabbed group is collapsed to icons (built-in workspaces: expanded).
+    pub dock_collapsed: bool,
     pub open_panel: Option<String>,
     pub status_bar: bool,
 }
@@ -115,6 +117,7 @@ pub fn capture(ui: &UiState, name: &str) -> Workspace {
         task_bar: ui.task_bar,
         dock: ui.dock,
         dock_tab: ui.dock_tab,
+        dock_collapsed: ui.dock_collapsed,
         open_panel: ui.open_panel.clone(),
         status_bar: ui.status_bar,
     }
@@ -130,6 +133,7 @@ pub fn apply(ui: &mut UiState, w: &Workspace) {
     ui.task_bar = w.task_bar;
     ui.dock = w.dock;
     ui.dock_tab = w.dock_tab;
+    ui.dock_collapsed = w.dock_collapsed;
     ui.open_panel = w.open_panel.clone();
     ui.status_bar = w.status_bar;
     ui.flyout = None;