@@ -1486,6 +1486,16 @@ Each category can be independently toggled on/off in preferences (Hot Paths sect
 
 Selecting an entry navigates via `navigate_to_path`, which takes the whole `VfsPath` — `vfs_id` included, so an entry on a mounted VFS lands on that VFS. Removal is keyed by `bookmark_key`, the verbatim `[[bookmark]]` `path` from settings.toml, which is a display path rather than the wire form.
 
+### Go to File (Mod+G)
+
+A palette that finds files and folders anywhere under the active pane's directory by name, as you type — the file manager's take on VS Code's Ctrl+P. Enter focuses the chosen entry in the pane it was opened from: the pane goes to the entry's folder and puts the cursor on it, a folder as much as a file. Opening it from there is the pane's own Enter, so Mod+G, a few characters, Enter, Enter opens a file through its association.
+
+- **Live**: the directory is walked when the palette opens, nearest entries first (breadth-first: everything in a folder before anything in its subfolders), and results appear and re-rank while the walk goes on. A status line under the input counts the entries seen ("Searching… 12,345 items"), says when the walk stopped at the limit, and how many folders couldn't be read. Nothing is cached: each opening walks afresh, and closing the palette stops the walk.
+- **Matching** is VS Code's: an entry matches when the query's characters appear in its path in order, ignoring case — `fobr` finds `foo_bar.txt`. Spaces split the query into pieces that all have to match (`pane tsx`). There is no other query syntax.
+- **Ranking**: a match within the name ranks above one that needs the folders too, so `pane` puts `Pane.tsx` before `pane_helpers/x.ts`, while `mw/pane` still reaches `main_window/Pane.tsx`. Among matches of the same kind, runs of consecutive characters and characters at word starts (after `/`, `_`, `-`, `.`, a case change) score higher; ties go to the shallower entry, then the shorter path. With an empty query the list is simply the nearest entries. The top 100 are shown, with the matched characters in bold.
+- **What's left out**: hidden entries, unless the pane is showing hidden files; `.git` always; names matching `quick_open.exclude`; and, with `quick_open.gitignore` (on by default), whatever `.gitignore` files ignore — those in the folders walked, those in the folders above up to the repository's top, and the repository's `.git/info/exclude`. The user's global git excludes file is not consulted, and no `git` is run: the rules are read and applied as the walk goes, on any filesystem. Symlinked folders are entered only with `quick_open.follow_symlinks`; the walk stays on one filesystem and stops after `quick_open.limit` entries (200,000).
+- **Where it runs**: next to the files — in a remote session on the remote host, so only the top results cross the connection, whatever the size of the tree; this machine's own files, browsed from a remote session, are walked here. It works on any filesystem a pane can show: local, SFTP, S3, archives, disc images.
+
 ### Bookmark Operations
 
 - **Add Bookmark** (Mod+B): Bookmarks the active pane's current directory. Optional custom name (defaults to the directory name). Stored as `[[bookmark]]` in `settings.toml`. The new entry goes to the *top* of the list, and bookmarking an already-bookmarked path moves it there instead of adding a second copy (any duplicates a hand-edited file already had are collapsed at the same time).
@@ -1684,6 +1694,12 @@ system_bookmarks = true     # Show GTK bookmarks (Linux)
 mounts = true               # Show mounted volumes
 recent_folders = true       # Show recently visited directories
 
+[quick_open]                # Go to File (Mod+G)
+gitignore = true            # Leave out what .gitignore files and .git/info/exclude ignore
+follow_symlinks = false     # Enter folders reached through symlinks
+exclude = []                # Name globs never shown or descended into, e.g. ["node_modules", "*.pyc"]
+limit = 200000              # Entries looked at before the search stops
+
 [editor]
 word_wrap = false           # Default word wrap in the text editor (per-file toggle still overrides)
 
@@ -1728,6 +1744,7 @@ Four tabs:
   - Enum → dropdown.
   - Number → number input.
   - String → text input.
+  - List of strings → a text input per item with a × to remove it, and a dashed row at the end that adds what's typed into it (Enter or leaving the row); an item emptied out is removed.
   - Custom widgets for complex preferences (rendered below the description):
     - **Columns**: Visible/Hidden panels side by side — visible rows carry a drag handle (mouse drag to reorder, arrow keys when focused); checkboxes toggle simple columns; timestamps get a presentation dropdown (Date & time / Date only / Separate columns).
     - **Default Sort**: Dropdown for sort key + ascending checkbox.
@@ -2040,6 +2057,7 @@ Toggle visibility of files starting with `.` (dot files). The `..` parent direct
 | Mod+. | Copy pane path to other pane | Pane focused |
 | Mod+U | Swap panes (whole pane state, history included) | Pane focused |
 | Mod+P | Hot paths | Any |
+| Mod+G | Go to file | Any |
 | Mod+B | Add bookmark | Pane focused |
 | Mod+Shift+L | Select VFS | Pane focused |
 
 
@@ -154,7 +154,7 @@ OTHER DEALINGS IN THE FONT SOFTWARE.
 
 ## Rust crates
 
-732 crates, the superset across every target platform and feature.
+736 crates, the superset across every target platform and feature.
 
   adler2 2.0.1 — 0BSD OR MIT OR Apache-2.0
       Copyright (C) Jonas Schievink <jonasschievink@gmail.com>
@@ -385,6 +385,10 @@ OTHER DEALINGS IN THE FONT SOFTWARE.
       Copyright (c) 2018 Sam Rijs, Alex Crichton and contributors
   crossbeam-channel 0.5.17 — MIT OR Apache-2.0
       Copyright (c) 2019 The Crossbeam Project Developers
+  crossbeam-deque 0.8.8 — MIT OR Apache-2.0
+      Copyright (c) 2019 The Crossbeam Project Developers
+  crossbeam-epoch 0.9.21 — MIT OR Apache-2.0
+      Copyright (c) 2019 The Crossbeam Project Developers
   crossbeam-utils 0.8.23 — MIT OR Apache-2.0
       Copyright (c) 2019 The Crossbeam Project Developers
   crunchy 0.2.4 — MIT
@@ -651,6 +655,8 @@ OTHER DEALINGS IN THE FONT SOFTWARE.
       Copyright (c) 2013-2025 The rust-url developers
   idna_adapter 1.2.2 — Apache-2.0 OR MIT
       Copyright (c) The rust-url developers
+  ignore 0.4.33 — Unlicense OR MIT
+      Copyright (c) 2015 Andrew Gallant
   iluvatar 0.5.0 — MIT OR Apache-2.0
       Copyright (c) 2025 iluvatar contributors
   image 0.25.10 — MIT OR Apache-2.0
@@ -809,6 +815,7 @@ OTHER DEALINGS IN THE FONT SOFTWARE.
   notify 8.2.0 — CC0-1.0
   notify-types 2.1.0 — MIT OR Apache-2.0
       Copyright (c) 2023 Notify Contributors
+  nucleo-matcher 0.3.1 — MPL-2.0
   num 0.4.3 — MIT OR Apache-2.0
       Copyright (c) 2014 The Rust Project Developers
   num-bigint 0.4.8 — MIT OR Apache-2.0
 
@@ -104,6 +104,5 @@ Design: `design_docs/DESIGN_EXCLUSIVE_WRITES.md`.
 ## Major new features (groom/write design docs first)
 
 - Batch rename (probably with enrichers preview)
-- Quick Open (VS Code's Ctrl+P): fuzzy-find files under the current directory, as a lighter alternative to the search VFS — matches stream in live as the walk proceeds, and choosing one jumps to it. Wants a breadth-first mode for the walker (`libs/newt-common/src/vfs/walk.rs` is depth-first only) so near files surface first.
 - Compare & synchronize directories
 - Custom styling / theming
@@ -0,0 +1,54 @@
+import { behindDialog, docsColumns, PROJECT } from "../demo";
+import type { QuickOpenHit } from "../../../src/lib/bindings";
+import type { Scene } from "../types";
+
+// Ranked and highlighted as the backend ranks "visit" over the demo tree.
+const hit = (
+  rel: string,
+  highlights: number[],
+  is_dir = false,
+): QuickOpenHit => ({
+  rel,
+  is_dir,
+  highlights,
+});
+const results = [
+  hit("src/visitor", [4, 5, 6, 7, 8], true),
+  hit("docs/visitors.md", [5, 6, 7, 8, 9]),
+  hit("tests/visitor.rs", [6, 7, 8, 9, 10]),
+  hit("examples/visit_sizes.rs", [9, 10, 11, 12, 13]),
+  hit("src/visitor/mod.rs", [4, 5, 6, 7, 8]),
+  hit("src/visitor/sorted.rs", [4, 5, 6, 7, 8]),
+  hit("src/visitor/parallel.rs", [4, 5, 6, 7, 8]),
+];
+
+const scene: Scene = {
+  description: "Go to File finding entries under the project by name",
+  size: { width: 1000, height: 600 },
+  ...docsColumns(1000),
+  window: "main",
+  state: behindDialog({
+    type: "quick_open",
+    data: {
+      root: { vfs_id: 0, path: PROJECT },
+      root_display: PROJECT,
+      update: {
+        query: "visit",
+        results,
+        matched: results.length,
+        walked: 1284,
+        walking: false,
+        unreadable: 0,
+        truncated: false,
+        error: null,
+      },
+    },
+    context: { pane_handle: 0 },
+  }),
+  commands: {
+    quick_open_query: () => null,
+  },
+  steps: [{ type: "visit" }],
+};
+
+export default scene;
@@ -349,6 +349,10 @@ async fn run_agent() -> Result<(), Error> {
     let dispatcher = FilesystemDispatcher::new(filesystem, outbox.clone())
         .chain(ShellServiceDispatcher::new(LocalShellService))
         .chain(EnricherDispatcher::new(outbox.clone(), enrichers))
+        .chain(newt_common::api::QuickOpenDispatcher::new(
+            outbox.clone(),
+            Arc::new(newt_common::quick_open::QuickOpen::new(registry.clone())),
+        ))
         .chain(TerminalDispatcher::new(
             newt_common::terminal::Local::with_shell_integration(shell_integration),
         ))
 
@@ -50,6 +50,8 @@ hyper = { version = "1", features = ["http1", "server", "client"] }
 clap = { version = "4", features = ["derive", "wrap_help"] }
 hyper-util = { version = "0.1", features = ["tokio"] }
 http-body-util = "0.1"
+nucleo-matcher = { version = "0.3", default-features = false, features = ["unicode-normalization", "unicode-casefold"] }
+ignore = "0.4"
 
 [dev-dependencies]
 serde_json = "1"
 
@@ -67,6 +67,13 @@ pub const API_SYSTEM_HOT_PATHS: Api = Api(500);
 pub const API_START_ENRICHMENT: Api = Api(700);
 pub const API_ENRICHMENT_EVENT: Api = Api(701);
 
+// Quick Open — long-lived streaming invoke; updates ride
+// API_QUICK_OPEN_UPDATE notifications and query changes come as
+// API_QUICK_OPEN_QUERY signals, both correlated by QuickOpenId.
+pub const API_QUICK_OPEN: Api = Api(710);
+pub const API_QUICK_OPEN_UPDATE: Api = Api(711);
+pub const API_QUICK_OPEN_QUERY: Api = Api(712);
+
 // Connect-dialog discovery — runs on the session owner, so pane-scoped
 // agent mounts list the targets they would actually reach.
 pub const API_DISCOVER_SSH_HOSTS: Api = Api(510);
@@ -670,6 +677,117 @@ impl Dispatcher for EnricherDispatcher {
     }
 }
 
+/// Serves Quick Open runs; the side of the session that owns the
+/// filesystem.
+pub struct QuickOpenDispatcher {
+    quick_open: Arc<crate::quick_open::QuickOpen>,
+    outbox: Outbox,
+    /// Each run's query, for the signals that change it.
+    queries: Mutex<HashMap<crate::quick_open::QuickOpenId, tokio::sync::watch::Sender<String>>>,
+}
+
+impl QuickOpenDispatcher {
+    pub fn new(outbox: Outbox, quick_open: Arc<crate::quick_open::QuickOpen>) -> Self {
+        Self {
+            quick_open,
+            outbox,
+            queries: Mutex::new(HashMap::new()),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl Dispatcher for QuickOpenDispatcher {
+    async fn invoke(&self, api: Api, req: bytes::Bytes) -> Result<Option<bytes::Bytes>, Error> {
+        use crate::quick_open::{QuickOpenId, QuickOpenOptions, QuickOpenUpdate};
+        if api != API_QUICK_OPEN {
+            return Ok(None);
+        }
+        let (id, root, options, query): (QuickOpenId, VfsPath, QuickOpenOptions, String) =
+            decode(&req[..])?;
+        let (query_tx, query_rx) = tokio::sync::watch::channel(query);
+        self.queries.lock().insert(id, query_tx);
+        struct Guard<'a> {
+            id: QuickOpenId,
+            queries: &'a Mutex<HashMap<QuickOpenId, tokio::sync::watch::Sender<String>>>,
+        }
+        impl Drop for Guard<'_> {
+            fn drop(&mut self) {
+                self.queries.lock().remove(&self.id);
+            }
+        }
+        let _guard = Guard {
+            id,
+            queries: &self.queries,
+        };
+
+        let (tx, mut rx) = tokio::sync::mpsc::channel::<QuickOpenUpdate>(4);
+        let run = self.quick_open.run(root, options, query_rx, tx);
+        tokio::pin!(run);
+        let ret = loop {
+            tokio::select! {
+                ret = &mut run => break ret,
+                update = rx.recv() => {
+                    let Some(update) = update else {
+                        break (&mut run).await;
+                    };
+                    self.outbox
+                        .send(Message::Notify(API_QUICK_OPEN_UPDATE, encode(&(id, update))?.into()))
+                        .await
+                        .map_err(|_| Error::connection())?;
+                }
+            }
+        };
+        Ok(Some(encode(&ret)?.into()))
+    }
+
+    async fn notify(&self, api: Api, req: bytes::Bytes) -> Result<bool, Error> {
+        if api != API_QUICK_OPEN_QUERY {
+            return Ok(false);
+        }
+        let (id, query): (crate::quick_open::QuickOpenId, String) = decode(&req[..])?;
+        // A run that has ended may still be sent the last keystrokes.
+        if let Some(tx) = self.queries.lock().get(&id) {
+            tx.send_replace(query);
+        }
+        Ok(true)
+    }
+}
+
+/// Routes Quick Open updates to the runs waiting for them; the side of
+/// the session that asked.
+pub struct QuickOpenUpdateDispatcher {
+    pending: crate::quick_open::PendingQuickOpens,
+}
+
+impl QuickOpenUpdateDispatcher {
+    pub fn new(pending: crate::quick_open::PendingQuickOpens) -> Self {
+        Self { pending }
+    }
+}
+
+#[async_trait::async_trait]
+impl Dispatcher for QuickOpenUpdateDispatcher {
+    async fn invoke(&self, _api: Api, _req: bytes::Bytes) -> Result<Option<bytes::Bytes>, Error> {
+        Ok(None)
+    }
+
+    async fn notify(&self, api: Api, req: bytes::Bytes) -> Result<bool, Error> {
+        if api != API_QUICK_OPEN_UPDATE {
+            return Ok(false);
+        }
+        let (id, update): (
+            crate::quick_open::QuickOpenId,
+            crate::quick_open::QuickOpenUpdate,
+        ) = decode(&req[..])?;
+        let tx = self.pending.lock().get(&id).cloned();
+        if let Some(tx) = tx {
+            let _ = tx.send(update).await;
+        }
+        Ok(true)
+    }
+}
+
 pub struct VfsMountDispatcher {
     vfs_manager: Box<dyn VfsManager>,
 }
 
@@ -11,6 +11,7 @@ pub mod hot_paths;
 pub mod locale;
 pub mod operation;
 pub mod proc;
+pub mod quick_open;
 pub mod rpc;
 pub mod shell;
 pub mod shell_control;