diff --git a/crates/engine/src/cmd/brushlib.rs b/crates/engine/src/cmd/brushlib.rs
index 04498111c..8f36e16f6 100644
--- a/crates/engine/src/cmd/brushlib.rs
+++ b/crates/engine/src/cmd/brushlib.rs
@@ -107,10 +107,14 @@ impl BrushLibrary {
     /// `name`: the brushes and every resource their art uses.
     pub fn from_document(src: &Document, names: &[String], name: String) -> std::result::Result<Self, String> {
         let all = brush::library(src);
-        if let Some(n) = names.iter().find(|n| !all.iter().any(|b| b.name == **n)) {
+        // Names looked up in sets: scanning the lists for each brush made a library of N brushes
+        // cost N² comparisons.
+        let have: HashSet<&str> = all.iter().map(|b| b.name.as_str()).collect();
+        if let Some(n) = names.iter().find(|n| !have.contains(n.as_str())) {
             return Err(format!("no brush `{n}`"));
         }
-        let picked = all.iter().filter(|b| names.is_empty() || names.contains(&b.name));
+        let wanted: HashSet<&str> = names.iter().map(String::as_str).collect();
+        let picked = all.iter().filter(|b| names.is_empty() || wanted.contains(b.name.as_str()));
         let clip = Clipboard::gather(src, picked.map(|b| stroke(&b.name)).collect());
         let mut doc = clip.to_document();
         for l in &mut doc.layers {
@@ -120,7 +124,8 @@ impl BrushLibrary {
         }
         // The brushes picked and those their art paints with, in the panel order of the document
         // they came from.
-        let brushes: Vec<Brush> = all.into_iter().filter(|b| clip.brushes.iter().any(|c| c.name == b.name)).collect();
+        let kept: HashSet<&str> = clip.brushes.iter().map(|c| c.name.as_str()).collect();
+        let brushes: Vec<Brush> = all.iter().filter(|b| kept.contains(b.name.as_str())).cloned().collect();
         brush::store(&mut doc, &brushes);
         doc.title = name.clone();
         Ok(Self { name, brushes, doc })
diff --git a/crates/engine/src/cmd/clipboard.rs b/crates/engine/src/cmd/clipboard.rs
index ec2722197..29933309e 100644
--- a/crates/engine/src/cmd/clipboard.rs
+++ b/crates/engine/src/cmd/clipboard.rs
@@ -161,10 +161,19 @@ impl Clipboard {
         d.para_styles = self.para_styles.clone().into();
         if !self.brushes.is_empty() {
             let mut lib = vectorcraft_brush::library(&d);
+            // Each brush's place in the library by name: finding it by scanning the growing list
+            // made a library of N brushes cost N² comparisons.
+            let mut at: std::collections::HashMap<String, usize> = std::collections::HashMap::new();
+            for (i, b) in lib.iter().enumerate() {
+                at.entry(b.name.clone()).or_insert(i);
+            }
             for b in &self.brushes {
-                match lib.iter_mut().find(|x| x.name == b.name) {
+                match at.get(&b.name).and_then(|&i| lib.get_mut(i)) {
                     Some(x) => *x = b.clone(),
-                    None => lib.push(b.clone()),
+                    None => {
+                        at.insert(b.name.clone(), lib.len());
+                        lib.push(b.clone());
+                    }
                 }
             }
             vectorcraft_brush::store(&mut d, &lib);
diff --git a/crates/engine/src/cmd/clipboard/resources.rs b/crates/engine/src/cmd/clipboard/resources.rs
index e6bd96371..6a436ab31 100644
--- a/crates/engine/src/cmd/clipboard/resources.rs
+++ b/crates/engine/src/cmd/clipboard/resources.rs
@@ -14,7 +14,7 @@
 //! uses its resources as they are now.
 
 use std::cell::OnceCell;
-use std::collections::{BTreeMap, BTreeSet};
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::sync::Arc;
 
 use serde_json::{Map, Value, json};
@@ -149,6 +149,39 @@ struct Defs<'a> {
     char_styles: &'a [TextStyleDef],
     para_styles: &'a [TextStyleDef],
     brushes: Brushes<'a>,
+    /// Where each name is defined, built the first time a kind is followed.
+    index: DefIndex,
+}
+
+/// The positions of a kind's definitions by name.
+type NameIndex = HashMap<String, Vec<usize>>;
+
+/// [`Defs`]' definitions by name (graphic styles by id), each kind indexed the first time a
+/// reference to it is followed: finding a name's definitions by scanning them all made a
+/// document or library of N definitions that use each other cost N² comparisons.
+#[derive(Default)]
+struct DefIndex {
+    swatches: OnceCell<NameIndex>,
+    symbols: OnceCell<NameIndex>,
+    patterns: OnceCell<NameIndex>,
+    styles: OnceCell<HashMap<u32, Vec<usize>>>,
+    char_styles: OnceCell<NameIndex>,
+    para_styles: OnceCell<NameIndex>,
+    brushes: OnceCell<NameIndex>,
+}
+
+/// The items of `list` named `name`, in order, `index` holding their positions (built from
+/// `list` the first time).
+fn named<'l, T>(index: &OnceCell<NameIndex>, list: &'l [T], name_of: impl Fn(&T) -> &str, name: &str) -> impl Iterator<Item = &'l T> {
+    let index = index.get_or_init(|| {
+        let mut by: NameIndex = HashMap::new();
+        for (i, item) in list.iter().enumerate() {
+            by.entry(name_of(item).to_string()).or_default().push(i);
+        }
+        by
+    });
+    let at: &[usize] = index.get(name).map_or(&[], Vec::as_slice);
+    at.iter().filter_map(move |&i| list.get(i))
 }
 
 /// The brushes references lead to: a document's library, read the first time a brush is used
@@ -178,6 +211,7 @@ impl<'a> Defs<'a> {
             char_styles: &d.char_styles,
             para_styles: &d.para_styles,
             brushes: Brushes::Lazy(d, brushes),
+            index: DefIndex::default(),
         }
     }
 }
@@ -219,8 +253,16 @@ impl Used {
     fn note<'a>(&mut self, defs: &Defs<'a>, r: Ref<'_>, todo: &mut Vec<Source<'a>>) {
         let (res, name) = match r {
             Ref::Style(id) => {
-                if self.styles.insert(id) {
-                    todo.extend(defs.styles.iter().filter(|g| g.id != 0 && g.id == id).map(|g| Source::Appearance(&g.appearance)));
+                if self.styles.insert(id) && id != 0 {
+                    let index = defs.index.styles.get_or_init(|| {
+                        let mut by: HashMap<u32, Vec<usize>> = HashMap::new();
+                        for (i, g) in defs.styles.iter().enumerate() {
+                            by.entry(g.id).or_default().push(i);
+                        }
+                        by
+                    });
+                    let at = index.get(&id).map_or(&[][..], Vec::as_slice);
+                    todo.extend(at.iter().filter_map(|&i| defs.styles.get(i)).map(|g| Source::Appearance(&g.appearance)));
                 }
                 return;
             }
@@ -237,15 +279,16 @@ impl Used {
             return;
         }
         set.insert(name.to_string());
+        let ix = &defs.index;
         match res {
             // A tint swatch's base, a gradient swatch's linked stops.
-            Res::Swatch => todo.extend(defs.swatches.iter().filter(|w| w.name == name).map(|w| Source::Paint(&w.paint))),
-            Res::Symbol => todo.extend(defs.symbols.iter().filter(|s| s.name == name).map(|s| Source::Node(&s.art))),
-            Res::Pattern => todo.extend(defs.patterns.iter().filter(|p| p.name == name).flat_map(|p| p.art.iter().map(|a| Source::Node(a)))),
-            Res::CharStyle => todo.extend(defs.char_styles.iter().filter(|s| s.name == name).map(|s| Source::Attrs(&s.attrs))),
-            Res::ParaStyle => todo.extend(defs.para_styles.iter().filter(|s| s.name == name).map(|s| Source::Attrs(&s.attrs))),
+            Res::Swatch => todo.extend(named(&ix.swatches, &defs.swatches, |w| &w.name, name).map(|w| Source::Paint(&w.paint))),
+            Res::Symbol => todo.extend(named(&ix.symbols, defs.symbols, |s| &s.name, name).map(|s| Source::Node(&s.art))),
+            Res::Pattern => todo.extend(named(&ix.patterns, defs.patterns, |p| &p.name, name).flat_map(|p| p.art.iter().map(|a| Source::Node(a)))),
+            Res::CharStyle => todo.extend(named(&ix.char_styles, defs.char_styles, |s| &s.name, name).map(|s| Source::Attrs(&s.attrs))),
+            Res::ParaStyle => todo.extend(named(&ix.para_styles, defs.para_styles, |s| &s.name, name).map(|s| Source::Attrs(&s.attrs))),
             // A scatter or art brush's art, a pattern brush's tiles.
-            Res::Brush => todo.extend(defs.brushes.get().iter().filter(|b| b.name == name).flat_map(|b| b.art().into_iter().map(Source::Node))),
+            Res::Brush => todo.extend(named(&ix.brushes, defs.brushes.get(), |b| &b.name, name).flat_map(|b| b.art().into_iter().map(Source::Node))),
             _ => {}
         }
     }
@@ -649,6 +692,7 @@ impl Clipboard {
             char_styles: &self.char_styles,
             para_styles: &self.para_styles,
             brushes: Brushes::Ready(&self.brushes),
+            index: DefIndex::default(),
         };
         Used::of(&defs, &self.nodes)
     }
@@ -671,7 +715,7 @@ impl Clipboard {
         self.import_swatches(d, &used, choices, same_doc, &mut out);
         // Brushes whose art shows no symbols or patterns, before the symbols and patterns whose art
         // they may brush; the others once those are in.
-        let mut added_brushes = self.import_brushes(d, &used, same_doc, false, &mut out);
+        let mut added_brushes: HashSet<String> = self.import_brushes(d, &used, same_doc, false, &mut out).into_iter().collect();
         // Character and paragraph styles (their colours relinked first).
         for (r, mine, theirs) in [(Res::CharStyle, &self.char_styles, &mut d.char_styles), (Res::ParaStyle, &self.para_styles, &mut d.para_styles)] {
             for def in mine.iter().filter(|s| used.has(r, &s.name)) {
@@ -683,14 +727,14 @@ impl Clipboard {
         }
         // Symbols and patterns, compared once relinked. Those added are relinked at the end, when
         // every new name and graphic style id is known.
-        let mut added_symbols = vec![];
+        let mut added_symbols = HashSet::new();
         for def in self.symbols.iter().filter(|s| used.has(Res::Symbol, &s.name)) {
             let r = &out.relink;
             let p = place(&mut d.symbols, def, same_doc, |a, b| same_art(r, std::slice::from_ref(&a.art), std::slice::from_ref(&b.art)));
             added_symbols.extend(p.new_name(&def.name));
             out.placed(Res::Symbol, &def.name, &p);
         }
-        let mut added_patterns = vec![];
+        let mut added_patterns = HashSet::new();
         for def in self.patterns.iter().filter(|p| used.has(Res::Pattern, &p.name)) {
             // Tile options alike, and the art once relinked.
             let bare = |p: &PatternDef| PatternDef { name: String::new(), art: vec![], ..p.clone() };
diff --git a/crates/engine/src/cmd/symbollib.rs b/crates/engine/src/cmd/symbollib.rs
index 49e9f5a61..e5f2ccfe2 100644
--- a/crates/engine/src/cmd/symbollib.rs
+++ b/crates/engine/src/cmd/symbollib.rs
@@ -7,7 +7,7 @@
 //! document VectorCraft opens. `symbol.addFromLibrary` copies symbols into the document;
 //! `symbol.saveLibrary` writes the document's.
 
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 use std::sync::{Arc, LazyLock};
 
 use serde_json::{Value, json};
@@ -104,10 +104,17 @@ impl SymbolLibrary {
     /// `name`: the symbols, the symbols they nest and every other resource they use, with their
     /// Symbol Options.
     pub fn from_document(src: &Document, names: &[String], name: String) -> std::result::Result<Self, String> {
-        if let Some(n) = names.iter().find(|n| !src.symbols.iter().any(|s| s.name == **n)) {
+        // Each name's first place in the panel, looked up rather than scanned for: scanning the
+        // symbols for each one made a library of N symbols cost N² comparisons.
+        let mut order: HashMap<&str, usize> = HashMap::new();
+        for (i, s) in src.symbols.iter().enumerate() {
+            order.entry(s.name.as_str()).or_insert(i);
+        }
+        if let Some(n) = names.iter().find(|n| !order.contains_key(n.as_str())) {
             return Err(format!("no symbol `{n}`"));
         }
-        let picked = src.symbols.iter().filter(|s| names.is_empty() || names.contains(&s.name));
+        let wanted: HashSet<&str> = names.iter().map(String::as_str).collect();
+        let picked = src.symbols.iter().filter(|s| names.is_empty() || wanted.contains(s.name.as_str()));
         let clip = Clipboard::gather(src, picked.map(|s| instance(&s.name)).collect());
         let mut doc = clip.to_document();
         for l in &mut doc.layers {
@@ -116,8 +123,7 @@ impl SymbolLibrary {
             }
         }
         // The panel order of the document they came from.
-        let order = |n: &str| src.symbols.iter().position(|s| s.name == n);
-        doc.symbols.sort_by_key(|s| order(&s.name));
+        doc.symbols.sort_by_key(|s| order.get(s.name.as_str()).copied());
         for s in &doc.symbols.clone() {
             copy_options(src, &s.name, &mut doc, &s.name);
         }
@@ -344,3 +350,28 @@ fn load(s: &mut Session, p: &Value) -> Result<Value> {
     })?;
     Ok(json!({"library": info.id, "name": info.name, "count": lib.len()}))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// A library made from thousands of symbols holds them all, once each, in the panel order of
+    /// the document they came from, a name given twice kept at its first place.
+    #[test]
+    fn many_symbols_keep_their_panel_order() {
+        let mut src = Document::new(100.0, 100.0);
+        let n = 4000;
+        // Names out of alphabetical order, so the order kept is the panel's.
+        src.symbols = (0..n).map(|i| Symbol { name: format!("s{}", (i * 7919) % n), art: Arc::new(Node::group(NodeId(i as u64 + 1), vec![])), dynamic: false }).collect();
+        let lib = SymbolLibrary::from_document(&src, &[], "Many".into()).unwrap();
+        let names = |d: &Document| d.symbols.iter().map(|s| s.name.clone()).collect::<Vec<_>>();
+        assert_eq!(names(&lib.doc), names(&src));
+        let picked = ["s3".to_string(), "s1".to_string()];
+        let lib = SymbolLibrary::from_document(&src, &picked, "Two".into()).unwrap();
+        let order = |name: &str| src.symbols.iter().position(|s| s.name == name);
+        let mut want = vec!["s3", "s1"];
+        want.sort_by_key(|n| order(n));
+        assert_eq!(names(&lib.doc), want);
+        assert!(SymbolLibrary::from_document(&src, &["nope".to_string()], "None".into()).is_err());
+    }
+}