standalone flag

KeyEncoder mapped TAB to a plain tab regardless of Shift, so Shift+Tab sent the
same byte as Tab. Apps that use backtab for reverse navigation (fish completion
menu, helix theme picker) never saw it. Emit CSI Z when Shift is held.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
(cherry picked from commit 93d53fcef6)

.gitattributes

@@ -0,0 +1 @@
+*.mp4 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1 +1,20 @@
 result
+
+# Devenv
+.devenv*
+devenv.local.nix
+devenv.local.yaml
+
+# direnv
+.direnv
+
+# pre-commit
+.pre-commit-config.yaml
+build
+.gradle
+bin
+.settings
+.project
+.worktrees
+.classpath
+.codexsession

.ignore

@@ -0,0 +1,4 @@
+.gradle
+bin
+result
+.worktrees

README.md

@@ -1,24 +1,117 @@
 # jprototerm
 
-JavaFX canvas terminal prototype using `jlibghostty` for terminal emulation, Nix for the build environment, and GluonFX/GraalVM Native Image for the Linux binary.
+JavaFX canvas terminal prototype using `jlibghostty` for terminal emulation and Nix for
+the build environment. It builds a plain JavaFX application (JDK 25, JavaFX 25 via Gradle)
+packaged as a Nix derivation — no GraalVM/GluonFX native image. It supports tiled and
+floating panes and tabs.
+
+> [!CAUTION]
+> `nix profile add` has only been tested on **Debian with the proprietary NVIDIA driver**.
+> The runtime GL shim hardcodes Debian's `/lib/x86_64-linux-gnu` driver paths and selects
+> the NVIDIA GLX/EGL vendor, so it likely won't work yet on other distros, Wayland-only
+> setups, or Mesa/AMD/Intel GPUs. I'm happy to accept pull requests that broaden host
+> support.
+
+<video src="https://gitea.gregorlohaus.com/gregor/jprototerm/media/branch/main/demo.mp4" controls></video>
 
 ## Build
 
 ```sh
 nix build
+./result/bin/jprototerm
 ```
 
-The package build compiles with Nix-provided OpenJFX 25, `jlibghostty`, JToml, and GraalVM Native Image directly so it does not depend on Gradle plugin resolution inside the Nix sandbox.
+Install it into a profile (see the caution above on host support):
+
+```sh
+nix profile add .
+jprototerm
+```
+
+Or install straight from the remote — note the `git+https://` scheme (a bare `https://`
+URL is treated as a tarball, not a git repo):
+
+```sh
+nix profile add git+https://gitea.gregorlohaus.com/gregor/jprototerm
+```
+
+Add `?ref=<branch-or-tag>` to pin a revision. The target machine needs Nix with the
+`nix-command` and `flakes` features enabled and network access — the build fetches the
+`jlibghostty`/`ghostty` flake inputs plus the JDK and Gradle from the binary caches.
+
+The flake bundles everything the app needs — the JDK 25 runtime, the Maven JavaFX modules
+and their native libraries, and the gtk/glib/freetype/X11 libraries they load — **except**
+the system OpenGL/graphics drivers. `libGL` is supplied by the host at runtime through a GL
+shim in the launcher wrapper, so the same closure runs against NixOS, Mesa, or vendor
+(e.g. NVIDIA) GPU drivers.
+
+Gradle dependencies are vendored in `deps.json` for the pure Nix sandbox. Regenerate it
+after changing dependencies in `build.gradle` (the update script writes `deps.json` in the
+current directory):
+
+```sh
+$(nix build .#gradleDepsUpdateScript --no-link --print-out-paths)
+```
 
 For development:
 
 ```sh
 nix develop
-gradle -PjlibghosttyMavenRepo="$JLIBGHOSTTY_MAVEN_REPO" run
-gradle -PjlibghosttyMavenRepo="$JLIBGHOSTTY_MAVEN_REPO" nativeCompile
+gradle run
 ```
 
-The Gradle project is kept for interactive development and IDE import.
+The Gradle project is the source of truth for the JavaFX build.
+
+## Daemon (optional, faster launches)
+
+Cold start pays for JVM + JavaFX + GL/X11 init every time. The optional daemon keeps one JVM
+(one toolkit) running and hosts every window in it, so a `jprototerm` launch just asks the
+daemon to open a window — it appears without paying that startup cost again.
+
+Run it once in the background:
+
+```sh
+jprototerm --daemon &
+```
+
+After that, a bare `jprototerm` connects to the daemon and opens a window in the current
+directory. If no daemon is running, `jprototerm` falls back to a standalone in-process window
+(today's behavior), so it always works.
+
+For development testing, use `jprototerm --standalone` to skip the daemon even when one is
+running.
+
+To start the daemon automatically with your graphical session, enable the bundled **user**
+service (it's a user service, not a system one, because X11 needs a display — which only
+exists after you log in):
+
+```sh
+mkdir -p ~/.config/systemd/user
+ln -sf "$(dirname "$(readlink -f "$(command -v jprototerm)")")/../share/systemd/user/jprototerm.service" \
+  ~/.config/systemd/user/jprototerm.service
+systemctl --user enable --now jprototerm.service
+```
+After upgrading via nix profile upgrade: 
+```sh
+systemctl --user disable jprototerm
+ln -sf "$(dirname "$(readlink -f "$(command -v jprototerm)")")/../share/systemd/user/jprototerm.service" \
+  ~/.config/systemd/user/jprototerm.service
+systemctl --user enable --now jprototerm.service
+systemctl --user restart jprototerm.service
+```
+
+If the daemon can't reach your display (e.g. `systemctl --user status jprototerm` shows it
+failing to open a window), import the session variables once and restart it:
+
+```sh
+systemctl --user import-environment DISPLAY XAUTHORITY
+systemctl --user restart jprototerm.service
+```
+
+Closing a window (the WM close button, or the close-pane key on the last pane) tears that
+window down — its shell processes are signalled with the configured `close_signal` — without
+affecting other windows or the daemon. Stop the daemon (and all its windows) with
+`systemctl --user stop jprototerm.service`, or `pkill -f 'jprototerm --daemon'`.
 
 ## Config
 
@@ -34,6 +127,8 @@ If `XDG_CONFIG_HOME` is unset, the fallback is:
 $HOME/.config/jprototerm/config.toml
 ```
 
+If no config file exists, jprototerm writes the default config on startup.
+
 Example, also available in `config.example.toml`:
 
 ```toml
@@ -51,17 +146,50 @@ height = 760
 [kitty_graphics]
 enabled = true
 
+[scrollback]
+editor_command = "vi {file}"
+
+[worktree]
+relative_worktree_path = "./.worktrees"
+
+[env.override]
+ZELLIJ_SESSION_NAME = ""
+
 [keybindings]
 navigate_left = "ALT+H"
 navigate_down = "ALT+J"
 navigate_up = "ALT+K"
 navigate_right = "ALT+L"
 toggle_floating = "ALT+F"
+new_pane = "ALT+N"
+next_floating = "ALT+F12"
+close_pane = "ALT+X"
+new_tab = "ALT+A"
+previous_tab = "ALT+SHIFT+H"
+next_tab = "ALT+SHIFT+L"
+open_font_selector = "ALT+T"
+open_scrollback = "ALT+S"
+create_worktree = "ALT+W"
 ```
 
 ## Defaults
 
 - `Alt+h/j/k/l`: navigate panes
-- `Alt+f`: open or close a floating pane
-- Font default: `Symbols Nerd Font Mono`
+- `Alt+n`: new pane — a floating pane when floating panes are shown, otherwise a new tiled
+  pane (tiled panes are split equally across the width)
+- `Alt+f`: show or hide all floating panes
+- `Alt+F12`: cycle floating panes
+- `Alt+x`: close the active pane; closing a tab's last pane closes the tab, and closing the
+  last pane of the last tab quits
+- `Alt+a`: new tab
+- `Alt+Shift+h` / `Alt+Shift+l`: previous / next tab
+- `Alt+t`: open the font selector
+- `Alt+s`: open the active pane scrollback in `$EDITOR`
+- `Alt+w`: edit a worktree name, then run `git worktree add <relative_worktree_path>/<name>`
+  from the previously focused pane's working directory
+- Font default: `JetBrainsMono Nerd Font`
 - Kitty graphics protocol parsing is enabled by default
+
+Each tab has its own stack of tiled and floating panes; only the active tab is rendered. A
+thin tab bar appears at the top when more than one tab is open. Closing the last tiled pane
+while floating panes exist promotes the most recently active floating pane to a tiled pane.

TODOS.md

@@ -0,0 +1,2 @@
+jlibghostty - why downcall metadata not propagated ?
+jlibghostty - how need to change flake so consuming flakes dont have to depend on same ghostty flake ?

build.gradle

@@ -0,0 +1,30 @@
+plugins {
+    id 'application'
+    id 'org.openjfx.javafxplugin' version '0.1.0'
+}
+
+repositories {
+    mavenCentral()
+
+    maven {
+        url = uri(System.getenv("JLIBGHOSTTY_MAVEN_REPO"))
+    }
+}
+
+dependencies {
+    implementation 'io.github.wasabithumb:jtoml:1.5.2'
+    implementation 'dev.jlibghostty:jlibghostty:0.1.0-SNAPSHOT'
+}
+
+javafx {
+    version = '25'
+    modules = [ 'javafx.controls', 'javafx.fxml' ]
+}
+
+application {
+    mainClass = 'com.gregor.jprototerm.Main'
+}
+
+run {
+    jvmArgs += ['--enable-native-access=ALL-UNNAMED']
+}

build.gradle.kts

@@ -1,32 +0,0 @@
-plugins {
-    application
-    id("org.openjfx.javafxplugin") version "0.1.0"
-    id("com.gluonhq.gluonfx-gradle-plugin") version "1.0.28"
-}
-
-group = "com.gregor"
-version = "0.1.0"
-
-dependencies {
-    implementation("dev.jlibghostty:jlibghostty:0.1.0-SNAPSHOT")
-    implementation("io.github.wasabithumb:jtoml:1.5.2")
-}
-
-java {
-    toolchain {
-        languageVersion.set(JavaLanguageVersion.of(25))
-    }
-}
-
-application {
-    mainClass.set("com.gregor.jprototerm.Main")
-}
-
-javafx {
-    version = "25"
-    modules = listOf("javafx.controls", "javafx.graphics")
-}
-
-gluonfx {
-    mainClassName = "com.gregor.jprototerm.Main"
-}

config.example.toml

@@ -1,7 +1,11 @@
 [terminal]
 columns = 100
 rows = 30
+max_scrollback = 100000
 shell = "/bin/bash"
+# Signal sent to a pane's shell process when the pane is closed (e.g. ALT+X).
+# Use SIGKILL to force-kill instead of asking the shell to terminate.
+close_signal = "SIGTERM"
 font_family = "JetBrainsMono Nerd Font"
 font_size = 15
 
@@ -12,9 +16,29 @@ height = 760
 [kitty_graphics]
 enabled = true
 
+[scrollback]
+editor_command = "vi {file}"
+
+[worktree]
+relative_worktree_path = "./.worktrees"
+
+[env.override]
+ZELLIJ_SESSION_NAME = ""
+
 [keybindings]
 navigate_left = "ALT+H"
 navigate_down = "ALT+J"
 navigate_up = "ALT+K"
 navigate_right = "ALT+L"
 toggle_floating = "ALT+F"
+new_pane = "ALT+N"
+next_floating = "ALT+F12"
+promote_floating = "ALT+P"
+close_pane = "ALT+X"
+new_tab = "ALT+A"
+previous_tab = "ALT+SHIFT+H"
+next_tab = "ALT+SHIFT+L"
+open_font_selector = "ALT+T"
+open_scrollback = "ALT+S"
+create_worktree = "ALT+W"
+paste = "CTRL+SHIFT+V"

deps.json

@@ -0,0 +1,76 @@
+{
+ "!comment": "This is a nixpkgs Gradle dependency lockfile. For more details, refer to the Gradle section in the nixpkgs manual.",
+ "!version": 1,
+ "https://plugins.gradle.org/m2": {
+  "com/google/code/findbugs#jsr305/3.0.2": {
+   "jar": "sha256-dmrSoHg/JoeWLIrXTO7MOKKLn3Ki0IXuQ4t4E+ko0Mc=",
+   "pom": "sha256-GYidvfGyVLJgGl7mRbgUepdGRIgil2hMeYr+XWPXjf4="
+  },
+  "com/google/gradle#osdetector-gradle-plugin/1.7.3": {
+   "jar": "sha256-a0aS+ROiGx+2Axae54uo8+SrKvnXYq+cqIt5EmwcCtE=",
+   "pom": "sha256-hGDJUBJ8o1mHZhYeOLT/jWO01p+4MQoW4As1E1ABDBE="
+  },
+  "kr/motd/maven#os-maven-plugin/1.7.1": {
+   "jar": "sha256-9Hru+Ggh5SsrGHWJeL0EXwPXIikuMudHCCEixiKJUuA=",
+   "pom": "sha256-S3WABEIrljPdMY8p54Tx0YC9ilkgzVCvGTCGH21qVHY="
+  },
+  "org/openjfx#javafx-plugin/0.1.0": {
+   "jar": "sha256-Xq7sB5m0QGRrDKTP2iGaMttr4rpXktAyoNpKOlw4j6s=",
+   "module": "sha256-rf+3RA0kntF8BJOD1nBp+UU7F3gncMAFtoKkNBbYNmE=",
+   "pom": "sha256-NMjfVSfrWjXl8AmjzeH3oInEzkoOclgC8uy+UDu9PLY="
+  },
+  "org/openjfx/javafxplugin#org.openjfx.javafxplugin.gradle.plugin/0.1.0": {
+   "pom": "sha256-1tASf/Q2PQAXPDV6mByec+/wPDCl0Ohq2CtgVPrvqEE="
+  },
+  "org/sonatype/oss#oss-parent/7": {
+   "pom": "sha256-tR+IZ8kranIkmVV/w6H96ne9+e9XRyL+kM5DailVlFQ="
+  },
+  "org/sonatype/oss#oss-parent/9": {
+   "pom": "sha256-+0AmX5glSCEv+C42LllzKyGH7G8NgBgohcFO8fmCgno="
+  }
+ },
+ "https://repo.maven.apache.org/maven2": {
+  "io/github/wasabithumb#jtoml-api/1.5.2": {
+   "jar": "sha256-3MvElpV+cmdqWO+SAHVKCWDYs+KMUXwIYYk7ax85yWo=",
+   "module": "sha256-RUZYGHsxZfuGBi5TogMHhWcbRcCUBTUAPN8FZpPszlE=",
+   "pom": "sha256-VOaIPO8w4z9saTR8smoLTSoih2PUFOBhBio9eqpoqo8="
+  },
+  "io/github/wasabithumb#jtoml-internals/1.5.2": {
+   "jar": "sha256-k4z/Uxzugk2hXUIdeeNLTz//NeynHzPfHCDXzDHP1Ys=",
+   "module": "sha256-OsnYjM8Tylw/MNdw0/HRUWvXgrQHdnT09O5vYlaZENU=",
+   "pom": "sha256-qXtmwHMJBNIWgrewEoUq1FBZjs2eRuRO1wMLndgsndg="
+  },
+  "io/github/wasabithumb#jtoml/1.5.2": {
+   "jar": "sha256-zDtf6VVGSrvC8StneL9fKq9LyaJSfiDb86w52s+bRYs=",
+   "module": "sha256-TRoE8nqf0ULuQ4J1/u2+voUNf421lTOJ1SajE07F8/Y=",
+   "pom": "sha256-sG4IDPD+ItRgyQcfDiLqdd+wCd40JHcSLocA+jWX1p0="
+  },
+  "org/openjfx#javafx-base/25": {
+   "pom": "sha256-XFYpcqK673qkB7J9Wc4XOl6lCht7dRgEO3/I92/v5Tc="
+  },
+  "org/openjfx#javafx-base/25/linux": {
+   "jar": "sha256-MkJZRruLjbBxfPovsuAOIc1InzW5ZitvrKGLYVpKlmk="
+  },
+  "org/openjfx#javafx-controls/25": {
+   "pom": "sha256-74cad6gX7nuDrKWKKe6yv5h2AvRseKHRXEYAgzpq1uM="
+  },
+  "org/openjfx#javafx-controls/25/linux": {
+   "jar": "sha256-NzVeTZHGfoj9mBX2AeasW1Xd3p9em5P8j0qgRXfmkdM="
+  },
+  "org/openjfx#javafx-fxml/25": {
+   "pom": "sha256-RopsFNQeVHnwNK4v4FPwyJEpfqJoo8dtf/047zyrsio="
+  },
+  "org/openjfx#javafx-fxml/25/linux": {
+   "jar": "sha256-OUrjL2TBIsFPvRDvSb3efbsFVpt6uOf58XDIGSS5Wis="
+  },
+  "org/openjfx#javafx-graphics/25": {
+   "pom": "sha256-zB2jY7Id7uvymRWBk9qmIB+USw+Setv13DhL62qDOfQ="
+  },
+  "org/openjfx#javafx-graphics/25/linux": {
+   "jar": "sha256-PlGLwX7lWFWaKsWKX3/UUmFRCNnVCI9lsTvuk5nDcis="
+  },
+  "org/openjfx#javafx/25": {
+   "pom": "sha256-55IzCPyt1/LGiwcgQfR9jnNVIj2EZVnutceA3EuivxM="
+  }
+ }
+}

flake.lock

@@ -64,53 +64,17 @@
         "type": "github"
       }
     },
-    "javafx-base": {
-      "flake": false,
-      "locked": {
-        "narHash": "sha256-96fttJUts/rFwKB7u5G8NWkK2NjJ3a6eIKbe1RTWkmM=",
-        "type": "file",
-        "url": "https://repo.maven.apache.org/maven2/org/openjfx/javafx-base/25/javafx-base-25-linux.jar"
-      },
-      "original": {
-        "type": "file",
-        "url": "https://repo.maven.apache.org/maven2/org/openjfx/javafx-base/25/javafx-base-25-linux.jar"
-      }
-    },
-    "javafx-controls": {
-      "flake": false,
-      "locked": {
-        "narHash": "sha256-2Cdc2/hPOjJmQidDjXu9vnlwAuawLn0cg/tLhzFfkUs=",
-        "type": "file",
-        "url": "https://repo.maven.apache.org/maven2/org/openjfx/javafx-controls/25/javafx-controls-25-linux.jar"
-      },
-      "original": {
-        "type": "file",
-        "url": "https://repo.maven.apache.org/maven2/org/openjfx/javafx-controls/25/javafx-controls-25-linux.jar"
-      }
-    },
-    "javafx-graphics": {
-      "flake": false,
-      "locked": {
-        "narHash": "sha256-w01IhRAQzcfTvwkqIQkjrI8ZPXT0VTEeijfzbqp3G0k=",
-        "type": "file",
-        "url": "https://repo.maven.apache.org/maven2/org/openjfx/javafx-graphics/25/javafx-graphics-25-linux.jar"
-      },
-      "original": {
-        "type": "file",
-        "url": "https://repo.maven.apache.org/maven2/org/openjfx/javafx-graphics/25/javafx-graphics-25-linux.jar"
-      }
-    },
     "jlibghostty": {
       "inputs": {
         "ghostty": "ghostty",
         "nixpkgs": "nixpkgs"
       },
       "locked": {
-        "lastModified": 1779889299,
-        "narHash": "sha256-B82MyhTvlfeszdcuM3F8YDSZYaxUom+m59oQKSoWjmQ=",
+        "lastModified": 1780363584,
+        "narHash": "sha256-BN6kwSBnlavuySut6vvLsfwkfKBjrPvFgJeeMMTXNtg=",
         "ref": "refs/heads/main",
-        "rev": "eea43843002f8fae4fa4cb1c46b64339124bf6b2",
-        "revCount": 6,
+        "rev": "1cd908e5d0070fdc1c86fc6b300cf1d6dbb5d184",
+        "revCount": 25,
         "type": "git",
         "url": "https://gitea.gregorlohaus.com/gregor/jlibghostty.git"
       },
@@ -119,18 +83,6 @@
         "url": "https://gitea.gregorlohaus.com/gregor/jlibghostty.git"
       }
     },
-    "jtoml-all": {
-      "flake": false,
-      "locked": {
-        "narHash": "sha256-KWrUaDVmnWzdkQxjgPFFNl8DOEvkCqWW3OmXU2sZHKw=",
-        "type": "file",
-        "url": "https://repo.maven.apache.org/maven2/io/github/wasabithumb/jtoml-all/1.5.2/jtoml-all-1.5.2.jar"
-      },
-      "original": {
-        "type": "file",
-        "url": "https://repo.maven.apache.org/maven2/io/github/wasabithumb/jtoml-all/1.5.2/jtoml-all-1.5.2.jar"
-      }
-    },
     "nixpkgs": {
       "locked": {
         "lastModified": 1779560665,
@@ -165,11 +117,11 @@
     },
     "root": {
       "inputs": {
-        "javafx-base": "javafx-base",
-        "javafx-controls": "javafx-controls",
-        "javafx-graphics": "javafx-graphics",
+        "ghostty": [
+          "jlibghostty",
+          "ghostty"
+        ],
         "jlibghostty": "jlibghostty",
-        "jtoml-all": "jtoml-all",
         "nixpkgs": "nixpkgs_2"
       }
     },

flake.nix

@@ -1,131 +1,196 @@
 {
-  description = "JavaFX terminal using jlibghostty and GraalVM Native Image";
+  description = "jprototerm";
 
   inputs = {
     nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
     jlibghostty.url = "git+https://gitea.gregorlohaus.com/gregor/jlibghostty.git";
-
-    jtoml-all = {
-      url = "https://repo.maven.apache.org/maven2/io/github/wasabithumb/jtoml-all/1.5.2/jtoml-all-1.5.2.jar";
-      flake = false;
+    ghostty.follows = "jlibghostty/ghostty";
   };
 
-    javafx-base = {
-      url = "https://repo.maven.apache.org/maven2/org/openjfx/javafx-base/25/javafx-base-25-linux.jar";
-      flake = false;
-    };
-
-    javafx-controls = {
-      url = "https://repo.maven.apache.org/maven2/org/openjfx/javafx-controls/25/javafx-controls-25-linux.jar";
-      flake = false;
-    };
-
-    javafx-graphics = {
-      url = "https://repo.maven.apache.org/maven2/org/openjfx/javafx-graphics/25/javafx-graphics-25-linux.jar";
-      flake = false;
-    };
-  };
-
-  outputs = {
-    self,
-    nixpkgs,
-    jlibghostty,
-    jtoml-all,
-    javafx-base,
-    javafx-controls,
-    javafx-graphics
-  }:
+  outputs = { self, nixpkgs, jlibghostty, ghostty }:
+    let
+      supportedSystems = [ "x86_64-linux" ];
+      forAllSystems = nixpkgs.lib.genAttrs supportedSystems;
+
+      # Everything the JavaFX natives (and jlibghostty) dlopen at runtime, EXCEPT the
+      # system OpenGL/graphics drivers. libGL is intentionally left out: it is supplied
+      # by the host at runtime via the GL shim in the wrapper below, so the same closure
+      # works on NixOS and on a plain Debian box with vendor GPU drivers installed.
+      runtimeLibsFor = pkgs: ghosttyVt: [
+        pkgs.glib
+        pkgs.gtk3
+        pkgs.pango
+        pkgs.cairo
+        pkgs.gdk-pixbuf
+        pkgs.harfbuzz
+        pkgs.freetype
+        pkgs.fontconfig.lib
+        pkgs.libx11
+        pkgs.libxext
+        pkgs.libxrender
+        pkgs.libxtst
+        pkgs.libxi
+        pkgs.libxcursor
+        pkgs.libxrandr
+        pkgs.libxinerama
+        pkgs.libxcb
+        pkgs.libxxf86vm
+        pkgs.zlib
+        ghosttyVt
+      ];
+    in {
+      packages = forAllSystems (system:
         let
-      system = "x86_64-linux";
           pkgs = import nixpkgs { inherit system; };
 
           jlib = jlibghostty.packages.${system}.jlibghostty;
-      graalvm = pkgs.graalvmPackages.graalvm-ce;
-      gradle = if pkgs ? gradle_9 then pkgs.gradle_9 else pkgs.gradle;
-      openjfx = pkgs.javaPackages.openjfx25;
-    in {
-      packages.${system}.default = pkgs.stdenvNoCC.mkDerivation {
+          ghosttyVt = ghostty.packages.${system}.libghostty-vt;
+
+          runtimeLibs = runtimeLibsFor pkgs ghosttyVt;
+
+          jprototerm = pkgs.stdenv.mkDerivation (finalAttrs: {
             pname = "jprototerm";
             version = "0.1.0";
             src = ./.;
 
             nativeBuildInputs = [
-          graalvm
+              pkgs.jdk25
+              pkgs.gradle_9
               pkgs.makeWrapper
             ];
 
-        buildPhase = ''
-          runHook preBuild
+            buildInputs = runtimeLibs;
 
-          mkdir -p build/classes build/native-image build/lib build/javafx-modules
+            mitmCache = pkgs.gradle_9.fetchDeps {
+              pkg = finalAttrs.finalPackage;
+              data = ./deps.json;
+              useBwrap = false;
+            };
 
-          find src/main/java -name '*.java' | sort > build/sources.txt
-          cp ${jtoml-all} build/lib/jtoml-all.jar
-          cp ${javafx-base} build/javafx-modules/javafx-base.jar
-          cp ${javafx-controls} build/javafx-modules/javafx-controls.jar
-          cp ${javafx-graphics} build/javafx-modules/javafx-graphics.jar
-          javafx_module_path="build/javafx-modules"
+            # Builds build/install/jprototerm/{bin,lib} with every runtime jar, including
+            # the maven javafx-*-linux jars that carry the platform natives.
+            gradleBuildTask = "installDist";
+            gradleFlags = [
+              "--no-build-cache"
+              "--stacktrace"
+              "-Dorg.gradle.java.home=${pkgs.jdk25}"
+            ];
 
-          jlib_classpath="$(
-            find ${jlib}/maven -type f -name '*.jar' \
-              ! -name '*-sources.jar' \
-              ! -name '*-javadoc.jar' \
-              | sort \
-              | paste -sd: -
-          )"
-          app_classpath="build/classes:build/lib/jtoml-all.jar:$jlib_classpath:build/javafx-modules/javafx-base.jar:build/javafx-modules/javafx-controls.jar:build/javafx-modules/javafx-graphics.jar"
+            JAVA_HOME = "${pkgs.jdk25}";
+            JLIBGHOSTTY_MAVEN_REPO = "${jlib}/maven";
 
-          javac \
-            --release 25 \
-            --module-path "$javafx_module_path" \
-            --add-modules javafx.controls,javafx.graphics \
-            -cp "build/lib/jtoml-all.jar:$jlib_classpath" \
-            -d build/classes \
-            @build/sources.txt
+            preBuild = ''
+              export HOME="$TMPDIR/home"
+              export GRADLE_OPTS="-Duser.home=$HOME ''${GRADLE_OPTS:-}"
+            '';
 
-          if [ -d src/main/resources ]; then
-            cp -R src/main/resources/. build/classes/
-          fi
-
-          native-image \
-            --no-fallback \
-            --enable-native-access=javafx.graphics \
-            --module-path "$javafx_module_path" \
-            --add-modules javafx.controls,javafx.graphics \
-            -cp "$app_classpath" \
-            -H:Class=com.gregor.jprototerm.Main \
-            -o build/native-image/jprototerm
-
-          runHook postBuild
+            preGradleUpdate = ''
+              export HOME="$TMPDIR/home"
             '';
 
             installPhase = ''
               runHook preInstall
 
-          mkdir -p $out/bin
-          cp build/native-image/jprototerm $out/bin/jprototerm
+              mkdir -p "$out/share/jprototerm"
+              cp -a build/install/jprototerm/lib "$out/share/jprototerm/lib"
 
-          wrapProgram $out/bin/jprototerm \
-            --set GDK_BACKEND x11 \
-            --set JAVA_TOOL_OPTIONS "-Dprism.order=sw" \
-            --prefix LD_LIBRARY_PATH : ${pkgs.lib.makeLibraryPath [ openjfx jlib ]}:${openjfx}/modules_libs/javafx.graphics \
-            --prefix PATH : ${pkgs.lib.makeBinPath [ pkgs.util-linux pkgs.bash ]}
+              # JavaFX is a set of proper modular jars: put them on the module path and
+              # keep the application + plain dependency jars on the classpath, so the two
+              # worlds do not collide.
+              mkdir -p "$out/share/jprototerm/javafx"
+              mv "$out/share/jprototerm/lib"/javafx-*.jar "$out/share/jprototerm/javafx/"
+
+              # Build an explicit colon-separated classpath. A "lib/*" glob would be
+              # expanded by the wrapper's shell before java sees it, breaking -cp.
+              classpath=""
+              for jar in "$out"/share/jprototerm/lib/*.jar; do
+                classpath="$classpath''${classpath:+:}$jar"
+              done
+
+              # The CDS archive records launch-time module/classpath properties, including
+              # Nix store paths. Key it by this build's launch shape so stale archives from a
+              # previous package path cannot be reused, and pass the flags on java's command
+              # line so terminal child processes do not inherit them through JAVA_TOOL_OPTIONS.
+              cdsArchive="app-$(printf '%s\n' \
+                "${pkgs.jdk25}" \
+                "$out" \
+                "$classpath" \
+                "$out/share/jprototerm/javafx" \
+                "--enable-native-access=ALL-UNNAMED,javafx.graphics" \
+                "--add-modules=javafx.controls,javafx.fxml" \
+                "com.gregor.jprototerm.Main" \
+                | sha256sum | cut -c1-16).jsa"
+
+              # Prism frees GPU textures (and the X11 pixmaps behind them) only from phantom-ref
+              # Disposers that run during a GC. This daemon is one long-lived JVM whose ~140MB heap
+              # never nears the multi-GB default ceiling, so G1 almost never collects, the Disposers
+              # never run, and orphaned render resources (closed panes/windows, resized backbuffers)
+              # pile up until the X server's VRAM is exhausted and the whole session freezes. -Xmx
+              # makes output churn drive GC; G1PeriodicGCInterval runs a concurrent (low-pause) GC on
+              # an idle timer so an idle daemon still reclaims. The live heap is tiny, so GC is cheap.
+              makeWrapper "${pkgs.jdk25}/bin/java" "$out/bin/jprototerm" \
+                --run 'if [ "$#" -eq 0 ]; then if [ -n "''${XDG_RUNTIME_DIR:-}" ]; then jprototermSock="$XDG_RUNTIME_DIR/jprototerm/daemon.sock"; else jprototermSock="/tmp/jprototerm-''${USER:-user}/daemon.sock"; fi; if [ -S "$jprototermSock" ] && printf "%s\n" "$(pwd)" | ${pkgs.socat}/bin/socat - UNIX-CONNECT:"$jprototermSock" >/dev/null 2>&1; then exit 0; fi; fi' \
+                --run 'export JPROTOTERM_HOST_LD_LIBRARY_PATH="''${LD_LIBRARY_PATH:-}"' \
+                --run 'cdsDir="''${XDG_CACHE_HOME:-$HOME/.cache}/jprototerm"; mkdir -p "$cdsDir"' \
+                --add-flags "-XX:+AutoCreateSharedArchive" \
+                --add-flags "-XX:SharedArchiveFile=\$cdsDir/$cdsArchive" \
+                --add-flags "-Xmx512m" \
+                --add-flags "-XX:G1PeriodicGCInterval=5000" \
+                --add-flags "--enable-native-access=ALL-UNNAMED,javafx.graphics" \
+                --add-flags "--module-path $out/share/jprototerm/javafx" \
+                --add-flags "--add-modules javafx.controls,javafx.fxml" \
+                --add-flags "-cp $classpath" \
+                --add-flags "com.gregor.jprototerm.Main" \
+                --prefix LD_LIBRARY_PATH : "${pkgs.lib.makeLibraryPath runtimeLibs}" \
+                --run 'glShimDir="''${XDG_RUNTIME_DIR:-/tmp}/jprototerm-gl"; mkdir -p "$glShimDir"; for lib in /lib/x86_64-linux-gnu/libGL.so.1 /lib/x86_64-linux-gnu/libGLX.so.0 /lib/x86_64-linux-gnu/libGLdispatch.so.0 /usr/lib/x86_64-linux-gnu/libGLX_nvidia.so* /usr/lib/x86_64-linux-gnu/libEGL_nvidia.so* /usr/lib/x86_64-linux-gnu/libnvidia*.so* /usr/lib/x86_64-linux-gnu/nvidia/current/lib*.so*; do [ -e "$lib" ] && ln -sfn "$lib" "$glShimDir/$(basename "$lib")"; done; export LD_LIBRARY_PATH="$glShimDir''${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"; export __GLX_VENDOR_LIBRARY_NAME="''${__GLX_VENDOR_LIBRARY_NAME:-nvidia}"; if [ -e /usr/share/glvnd/egl_vendor.d/10_nvidia.json ]; then export __EGL_VENDOR_LIBRARY_FILENAMES="''${__EGL_VENDOR_LIBRARY_FILENAMES:-/usr/share/glvnd/egl_vendor.d/10_nvidia.json}"; fi' \
+                --set JLIBGHOSTTY_LIBRARY "${ghosttyVt}/lib/libghostty-vt.so" \
+                --set GDK_BACKEND x11
+
+              # Optional background daemon: one JVM hosts every window, so client launches skip
+              # cold JVM/JavaFX/GL startup. A *user* service tied to graphical-session.target (X11
+              # needs a display, which only exists after login). Enable instructions are in README.
+              mkdir -p "$out/share/systemd/user"
+              cat > "$out/share/systemd/user/jprototerm.service" <<EOF
+              [Unit]
+              Description=jprototerm terminal daemon
+              PartOf=graphical-session.target
+              After=graphical-session.target
+
+              [Service]
+              Type=simple
+              ExecStart=$out/bin/jprototerm --daemon
+              Restart=on-failure
+
+              [Install]
+              WantedBy=graphical-session.target
+              EOF
 
               runHook postInstall
             '';
-      };
+          });
+        in {
+          default = jprototerm;
+          gradleDepsUpdateScript = jprototerm.mitmCache.updateScript;
+        });
 
-      devShells.${system}.default = pkgs.mkShell {
+      devShells = forAllSystems (system:
+        let
+          pkgs = import nixpkgs { inherit system; };
+          jlib = jlibghostty.packages.${system}.jlibghostty;
+          ghosttyVt = ghostty.packages.${system}.libghostty-vt;
+          runtimeLibs = runtimeLibsFor pkgs ghosttyVt;
+        in {
+          default = pkgs.mkShell {
             packages = [
-          graalvm
-          gradle
-          pkgs.util-linux
-        ];
+              pkgs.gradle_9
+              pkgs.jdk25
+              pkgs.jdt-language-server
+            ] ++ runtimeLibs;
 
-        shellHook = ''
-          export JLIBGHOSTTY_MAVEN_REPO=${jlib}/maven
-          echo "Use: gradle -PjlibghosttyMavenRepo=$JLIBGHOSTTY_MAVEN_REPO run"
-        '';
+            JLIBGHOSTTY_MAVEN_REPO = "${jlib}/maven";
+            JLIBGHOSTTY_LIBRARY = "${ghosttyVt}/lib/libghostty-vt.so";
+            LD_LIBRARY_PATH = pkgs.lib.makeLibraryPath runtimeLibs;
           };
+        });
     };
 }

settings.gradle

@@ -0,0 +1,8 @@
+pluginManagement {
+    repositories {
+        gradlePluginPortal()
+        mavenCentral()
+    }
+}
+
+rootProject.name = 'jprototerm'

settings.gradle.kts

@@ -1,22 +0,0 @@
-pluginManagement {
-    repositories {
-        gradlePluginPortal()
-        mavenCentral()
-    }
-}
-
-dependencyResolutionManagement {
-    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
-    repositories {
-        mavenCentral()
-        maven {
-            url = uri(
-                providers.gradleProperty("jlibghosttyMavenRepo")
-                    .orElse("../jlibghostty/result/maven")
-                    .get()
-            )
-        }
-    }
-}
-
-rootProject.name = "jprototerm"

src/main/java/com/gregor/jprototerm/AppConfig.java

@@ -3,29 +3,61 @@ package com.gregor.jprototerm;
 import io.github.wasabithumb.jtoml.JToml;
 import io.github.wasabithumb.jtoml.document.TomlDocument;
 import io.github.wasabithumb.jtoml.except.TomlException;
+import io.github.wasabithumb.jtoml.key.TomlKey;
 import io.github.wasabithumb.jtoml.value.TomlValue;
+import io.github.wasabithumb.jtoml.value.array.TomlArray;
 import io.github.wasabithumb.jtoml.value.primitive.TomlPrimitive;
 import io.github.wasabithumb.jtoml.value.table.TomlTable;
 
 import java.nio.file.Files;
+import java.io.IOException;
 import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 
 public record AppConfig(
         int columns,
         int rows,
-        String shell,
+        long maxScrollback,
+        List<String> shell,
         String fontFamily,
         double fontSize,
         double windowWidth,
         double windowHeight,
         boolean kittyGraphics,
+        String scrollbackEditorCommand,
+        String worktreeRelativePath,
+        String closeSignal,
+        Map<String, String> envOverride,
         Map<String, KeyBinding> keybindings
 ) {
+    private static final List<String> KEYBINDING_KEYS = List.of(
+            "navigate_left",
+            "navigate_down",
+            "navigate_up",
+            "navigate_right",
+            "toggle_floating",
+            "new_pane",
+            "next_floating",
+            "promote_floating",
+            "close_pane",
+            "new_tab",
+            "previous_tab",
+            "next_tab",
+            "open_font_selector",
+            "open_scrollback",
+            "create_worktree",
+            "paste"
+    );
+
     public static AppConfig load() {
         AppConfig defaults = defaults();
         Path path = configPath();
         if (!Files.isRegularFile(path)) {
+            save(path, defaults);
             return defaults;
         }
 
@@ -34,19 +66,18 @@ public record AppConfig(
             return new AppConfig(
                     intValue(document, "terminal.columns", defaults.columns),
                     intValue(document, "terminal.rows", defaults.rows),
-                    stringValue(document, "terminal.shell", defaults.shell),
+                    longValue(document, "terminal.max_scrollback", defaults.maxScrollback),
+                    stringListValue(document, "terminal.shell", defaults.shell),
                     stringValue(document, "terminal.font_family", defaults.fontFamily),
                     doubleValue(document, "terminal.font_size", defaults.fontSize),
                     doubleValue(document, "window.width", defaults.windowWidth),
                     doubleValue(document, "window.height", defaults.windowHeight),
                     booleanValue(document, "kitty_graphics.enabled", defaults.kittyGraphics),
-                    Map.of(
-                            "navigate_left", binding(document, "keybindings.navigate_left", defaults.keybindings.get("navigate_left")),
-                            "navigate_down", binding(document, "keybindings.navigate_down", defaults.keybindings.get("navigate_down")),
-                            "navigate_up", binding(document, "keybindings.navigate_up", defaults.keybindings.get("navigate_up")),
-                            "navigate_right", binding(document, "keybindings.navigate_right", defaults.keybindings.get("navigate_right")),
-                            "toggle_floating", binding(document, "keybindings.toggle_floating", defaults.keybindings.get("toggle_floating"))
-                    )
+                    stringValue(document, "scrollback.editor_command", defaults.scrollbackEditorCommand),
+                    stringValue(document, "worktree.relative_worktree_path", defaults.worktreeRelativePath),
+                    closeSignalValue(document, defaults.closeSignal),
+                    envOverride(document, defaults.envOverride),
+                    keybindings(document, defaults)
             );
         } catch (TomlException ex) {
             System.err.println("Could not parse " + path + ": " + ex.getMessage());
@@ -58,22 +89,71 @@ public record AppConfig(
         return new AppConfig(
                 100,
                 30,
+                100_000,
                 defaultShell(),
-                "Symbols Nerd Font Mono",
+                "JetBrainsMono Nerd Font",
                 15.0,
                 1200.0,
                 760.0,
                 true,
-                Map.of(
-                        "navigate_left", KeyBinding.parse("ALT+H"),
-                        "navigate_down", KeyBinding.parse("ALT+J"),
-                        "navigate_up", KeyBinding.parse("ALT+K"),
-                        "navigate_right", KeyBinding.parse("ALT+L"),
-                        "toggle_floating", KeyBinding.parse("ALT+F")
+                defaultScrollbackEditorCommand(),
+                "./.worktrees",
+                "SIGTERM",
+                Map.of(),
+                Map.ofEntries(
+                        Map.entry("navigate_left", KeyBinding.parse("ALT+H")),
+                        Map.entry("navigate_down", KeyBinding.parse("ALT+J")),
+                        Map.entry("navigate_up", KeyBinding.parse("ALT+K")),
+                        Map.entry("navigate_right", KeyBinding.parse("ALT+L")),
+                        Map.entry("toggle_floating", KeyBinding.parse("ALT+F")),
+                        Map.entry("new_pane", KeyBinding.parse("ALT+N")),
+                        Map.entry("next_floating", KeyBinding.parse("ALT+F12")),
+                        Map.entry("promote_floating", KeyBinding.parse("ALT+P")),
+                        Map.entry("close_pane", KeyBinding.parse("ALT+X")),
+                        Map.entry("new_tab", KeyBinding.parse("ALT+A")),
+                        Map.entry("previous_tab", KeyBinding.parse("ALT+SHIFT+H")),
+                        Map.entry("next_tab", KeyBinding.parse("ALT+SHIFT+L")),
+                        Map.entry("open_font_selector", KeyBinding.parse("ALT+T")),
+                        Map.entry("open_scrollback", KeyBinding.parse("ALT+S")),
+                        Map.entry("create_worktree", KeyBinding.parse("ALT+W")),
+                        Map.entry("paste", KeyBinding.parse("CTRL+SHIFT+V"))
                 )
         );
     }
 
+    public AppConfig withFont(String family, double size) {
+        return new AppConfig(
+                columns,
+                rows,
+                maxScrollback,
+                shell,
+                family,
+                size,
+                windowWidth,
+                windowHeight,
+                kittyGraphics,
+                scrollbackEditorCommand,
+                worktreeRelativePath,
+                closeSignal,
+                envOverride,
+                keybindings
+        );
+    }
+
+    /**
+     * The {@link #closeSignal} as a Linux signal number, sent to a pane's shell process when the
+     * pane is closed (e.g. via the close-pane key). Falls back to SIGTERM (15) if the configured
+     * name is somehow unresolvable.
+     */
+    public int closeSignalNumber() {
+        int number = LinuxPty.signalNumber(closeSignal);
+        return number < 0 ? 15 : number;
+    }
+
+    public void save() {
+        save(configPath(), this);
+    }
+
     public static Path configPath() {
         String configHome = System.getenv("XDG_CONFIG_HOME");
         if (configHome != null && !configHome.isBlank()) {
@@ -82,9 +162,123 @@ public record AppConfig(
         return Path.of(System.getProperty("user.home"), ".config", "jprototerm", "config.toml");
     }
 
-    private static String defaultShell() {
-        String shell = System.getenv("SHELL");
-        return shell == null || shell.isBlank() ? "/bin/sh" : shell;
+    private static List<String> defaultShell() {
+        // The executable plus its arguments, spawned verbatim. -i makes bash interactive; a
+        // different shell can use whatever flags it needs (or none) by editing this list.
+        return List.of("/bin/bash", "-i");
+    }
+
+    private static String defaultScrollbackEditorCommand() {
+        String editor = System.getenv("EDITOR");
+        if (editor == null || editor.isBlank()) {
+            editor = "vi";
+        }
+        return editor.trim() + " {file}";
+    }
+
+    /**
+     * Reads {@code terminal.close_signal}, normalising it to a canonical {@code SIG*} name. An
+     * unknown or unset value keeps {@code fallback} so a typo can't leave a pane unkillable.
+     */
+    private static String closeSignalValue(TomlTable table, String fallback) {
+        String value = stringValue(table, "terminal.close_signal", null);
+        if (value == null) {
+            return fallback;
+        }
+        if (LinuxPty.signalNumber(value) < 0) {
+            System.err.println("Unknown terminal.close_signal '" + value + "', using " + fallback);
+            return fallback;
+        }
+        String normalized = value.trim().toUpperCase(java.util.Locale.ROOT);
+        return normalized.startsWith("SIG") ? normalized : "SIG" + normalized;
+    }
+
+    private static Map<String, KeyBinding> keybindings(TomlTable table, AppConfig defaults) {
+        Map<String, KeyBinding> parsed = new LinkedHashMap<>();
+        for (String key : KEYBINDING_KEYS) {
+            parsed.put(key, binding(table, "keybindings." + key, defaults.keybindings.get(key)));
+        }
+        return Map.copyOf(parsed);
+    }
+
+    private static void save(Path path, AppConfig config) {
+        try {
+            Path parent = path.getParent();
+            if (parent != null) {
+                Files.createDirectories(parent);
+            }
+            Files.writeString(
+                    path,
+                    config.toToml(),
+                    StandardOpenOption.CREATE,
+                    StandardOpenOption.TRUNCATE_EXISTING,
+                    StandardOpenOption.WRITE
+            );
+        } catch (IOException ex) {
+            System.err.println("Could not write " + path + ": " + ex.getMessage());
+        }
+    }
+
+    private String toToml() {
+        StringBuilder builder = new StringBuilder();
+        builder.append("[terminal]\n");
+        builder.append("columns = ").append(columns).append('\n');
+        builder.append("rows = ").append(rows).append('\n');
+        builder.append("max_scrollback = ").append(maxScrollback).append('\n');
+        builder.append("shell = ").append(quotedList(shell)).append('\n');
+        builder.append("close_signal = ").append(quoted(closeSignal)).append('\n');
+        builder.append("font_family = ").append(quoted(fontFamily)).append('\n');
+        builder.append("font_size = ").append(trimDouble(fontSize)).append("\n\n");
+        builder.append("[window]\n");
+        builder.append("width = ").append(trimDouble(windowWidth)).append('\n');
+        builder.append("height = ").append(trimDouble(windowHeight)).append("\n\n");
+        builder.append("[kitty_graphics]\n");
+        builder.append("enabled = ").append(kittyGraphics).append("\n\n");
+        builder.append("[scrollback]\n");
+        builder.append("editor_command = ").append(quoted(scrollbackEditorCommand)).append("\n\n");
+        builder.append("[worktree]\n");
+        builder.append("relative_worktree_path = ").append(quoted(worktreeRelativePath)).append("\n\n");
+        builder.append("[env.override]\n");
+        for (Map.Entry<String, String> entry : envOverride.entrySet()) {
+            builder.append(entry.getKey()).append(" = ").append(quoted(entry.getValue())).append('\n');
+        }
+        builder.append('\n');
+        builder.append("[keybindings]\n");
+        for (String key : KEYBINDING_KEYS) {
+            KeyBinding binding = keybindings.get(key);
+            if (binding != null) {
+                builder.append(key).append(" = ").append(quoted(binding.toString())).append('\n');
+            }
+        }
+        return builder.toString();
+    }
+
+    private static String quotedList(List<String> values) {
+        StringBuilder builder = new StringBuilder("[");
+        for (int i = 0; i < values.size(); i++) {
+            if (i > 0) {
+                builder.append(", ");
+            }
+            builder.append(quoted(values.get(i)));
+        }
+        return builder.append("]").toString();
+    }
+
+    private static String quoted(String value) {
+        return "\"" + value
+                .replace("\\", "\\\\")
+                .replace("\"", "\\\"")
+                .replace("\n", "\\n")
+                .replace("\r", "\\r")
+                .replace("\t", "\\t")
+                + "\"";
+    }
+
+    private static String trimDouble(double value) {
+        if (value == Math.rint(value)) {
+            return Long.toString((long) value);
+        }
+        return Double.toString(value);
     }
 
     private static KeyBinding binding(TomlTable table, String key, KeyBinding fallback) {
@@ -99,12 +293,61 @@ public record AppConfig(
         }
     }
 
+    private static Map<String, String> envOverride(TomlTable table, Map<String, String> fallback) {
+        TomlValue value = table.get("env.override");
+        if (value == null || !value.isTable()) {
+            return fallback;
+        }
+
+        Map<String, String> result = new LinkedHashMap<>();
+        TomlTable overrides = value.asTable();
+        for (TomlKey key : overrides.keys(false)) {
+            if (key.size() != 1) {
+                continue;
+            }
+
+            TomlValue override = overrides.get(key);
+            if (override != null && override.isPrimitive()) {
+                try {
+                    result.put(key.get(0), override.asPrimitive().asString());
+                } catch (RuntimeException ignored) {
+                    // Ignore non-string values; environment values are strings.
+                }
+            }
+        }
+        return Map.copyOf(result);
+    }
+
     private static String stringValue(TomlTable table, String key, String fallback) {
         TomlPrimitive primitive = primitive(table, key);
         return primitive == null ? fallback : primitive.asString();
     }
 
+    /** Reads a TOML array of strings (e.g. {@code shell = ["/bin/bash", "-i"]}), or the fallback. */
+    private static List<String> stringListValue(TomlTable table, String key, List<String> fallback) {
+        TomlValue value = table.get(key);
+        if (value == null || !value.isArray()) {
+            return fallback;
+        }
+        List<String> result = new ArrayList<>();
+        for (TomlValue element : value.asArray()) {
+            if (element.isPrimitive()) {
+                try {
+                    result.add(element.asPrimitive().asString());
+                } catch (RuntimeException ignored) {
+                    // Skip non-string entries; a shell command line is a list of strings.
+                }
+            }
+        }
+        // An empty or all-invalid array would mean "no program to run"; keep the default instead.
+        return result.isEmpty() ? fallback : List.copyOf(result);
+    }
+
     private static int intValue(TomlTable table, String key, int fallback) {
+        return (int) longValue(table, key, fallback);
+    }
+
+    private static long longValue(TomlTable table, String key, long fallback) {
         TomlPrimitive primitive = primitive(table, key);
         if (primitive == null) {
             return fallback;

src/main/java/com/gregor/jprototerm/Compositor.java

@@ -0,0 +1,633 @@
+package com.gregor.jprototerm;
+
+import dev.jlibghostty.KeyModifiers;
+import dev.jlibghostty.MouseButton;
+import dev.jlibghostty.MouseEncoderSize;
+import dev.jlibghostty.MouseInput;
+import javafx.geometry.VPos;
+import javafx.scene.Node;
+import javafx.scene.canvas.Canvas;
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.input.InputEvent;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.input.ScrollEvent;
+import javafx.scene.input.ScrollEvent.VerticalTextScrollUnits;
+import javafx.scene.paint.Color;
+import javafx.scene.text.Font;
+import javafx.scene.text.FontSmoothingType;
+import javafx.scene.text.TextAlignment;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * Owns the window's tabs and drives rendering and input. It composites only the current tab:
+ * each frame it lays that tab out, paints the panes bottom-to-top (so the active floating pane
+ * lands on top) and lets each pane paint its own content, clipped to the region the layout gave
+ * it. The cross-pane concerns live here — the dirty-frame bookkeeping, the tab strip, routing
+ * mouse/scroll to the pane under the pointer, and the tab/pane lifecycle that {@link Main}'s key
+ * bindings invoke.
+ */
+public final class Compositor {
+    // Canvas background shown wherever no pane covers (gaps). Painted on a full recomposite.
+    private static final Color GAP_BACKGROUND = Color.rgb(16, 16, 18);
+    private static final Color TAB_TEXT = Color.rgb(225, 229, 235);
+    // Thin tab strip shown at the top when more than one tab is open.
+    private static final double TAB_BAR_HEIGHT = 22.0;
+
+    private final Canvas canvas = new Canvas();
+    // Kitty images are drawn as retained nodes layered over the canvas, not composited onto it.
+    private final KittyImageOverlay imageOverlay = new KittyImageOverlay();
+    private final AppConfig config;
+    private final TerminalMetrics metrics;
+    private final List<Tab> tabs = new ArrayList<>();
+    private int currentTabIndex;
+    // Bumped on any structural change (tab switch, pane add/close/focus/move) so render()
+    // knows to recomposite. Terminal *content* changes are tracked separately through each
+    // tab's content version.
+    private long layoutVersion;
+    // Last content version drawn to the canvas per pane, so a content frame repaints only
+    // the panes that actually changed.
+    private final Map<TerminalPane, Long> paneContentVersion = new HashMap<>();
+    // Off-screen panes (background tabs, hidden floating groups) keep their full-resolution pixel
+    // backbuffer + GPU image until released. We free them after a short grace period rather than the
+    // instant they're hidden, so rapidly flipping through tabs never thrashes the realloc/upload.
+    private static final long RELEASE_DELAY_NANOS = 750_000_000L;
+    // Hidden pane -> nanoTime it became hidden (the release timer); removed once released or shown.
+    private final Map<TerminalPane, Long> hiddenSince = new HashMap<>();
+    // Panes whose backbuffer is currently released, so we don't release again every frame.
+    private final Set<TerminalPane> released = new HashSet<>();
+    // layoutVersion at the last sweep: lets an idle, all-released steady state skip the scan.
+    private long lastSweepLayoutVersion = Long.MIN_VALUE;
+    // Cheap per-frame dirty signal: skip the whole render when none of these changed.
+    private double lastWidth = -1.0;
+    private double lastHeight = -1.0;
+    private String lastFontFamily;
+    private double lastFontSize = -1.0;
+    private long lastLayoutVersion = Long.MIN_VALUE;
+    private long lastContentVersion = Long.MIN_VALUE;
+    private boolean mouseButtonPressed;
+    private MouseButton pressedButton = MouseButton.UNKNOWN;
+    // Run when the last pane closes (so the window can quit). No-op until Main sets it.
+    private Runnable onEmpty = () -> {};
+
+    public Compositor(AppConfig config, TerminalMetrics metrics) {
+        this(config, metrics, null);
+    }
+
+    /**
+     * Creates a compositor whose first tab's first pane starts in {@code workingDirectory} (e.g. the
+     * cwd a client passed when asking the daemon to open this window), or the user's home when
+     * {@code null}.
+     */
+    public Compositor(AppConfig config, TerminalMetrics metrics, String workingDirectory) {
+        this.config = config;
+        this.metrics = metrics;
+        tabs.add(new Tab(config, metrics, workingDirectory, this::closePane));
+        canvas.setFocusTraversable(true);
+        canvas.setOnMousePressed(this::handleMousePressed);
+        canvas.setOnMouseReleased(this::handleMouseReleased);
+        canvas.setOnMouseDragged(this::handleMouseDragged);
+        canvas.setOnMouseMoved(this::handleMouseMoved);
+        canvas.setOnScroll(this::handleScroll);
+    }
+
+    public Canvas canvas() {
+        return canvas;
+    }
+
+    /** Sets the callback run when the last pane closes (e.g. to quit the application). */
+    public void setOnEmpty(Runnable onEmpty) {
+        this.onEmpty = onEmpty;
+    }
+
+    /** The kitty-image overlay, to be stacked directly above {@link #canvas()} in the window. */
+    public Node imageOverlay() {
+        return imageOverlay.node();
+    }
+
+    public void setFont(String family, double size) {
+        metrics.setFont(family, size);
+        paneContentVersion.clear();
+        layoutVersion++; // recomposite with the new metrics on the next frame
+    }
+
+    // ---- Tabs and panes -------------------------------------------------------------
+
+    public boolean isEmpty() {
+        return tabs.isEmpty();
+    }
+
+    /** The active pane of the current tab, or {@code null} when no tab is left. */
+    public TerminalPane activePane() {
+        return isEmpty() ? null : currentTab().activePane();
+    }
+
+    public void navigate(Direction direction) {
+        if (!isEmpty() && currentTab().navigate(direction)) {
+            layoutVersion++;
+        }
+    }
+
+    public void toggleFloating() {
+        mutateCurrentTab(() -> currentTab().toggleFloating());
+    }
+
+    public void createPane() {
+        mutateCurrentTab(() -> currentTab().createPane());
+    }
+
+    /**
+     * Opens a floating pane running {@code command} directly (auto-closing when it exits), makes it
+     * active, and returns it (null when no tab exists).
+     */
+    public TerminalPane openFloatingPane(String command) {
+        if (isEmpty()) {
+            return null;
+        }
+        TerminalPane pane = currentTab().createFloatingPane(command);
+        layoutVersion++;
+        return pane;
+    }
+
+    public void nextFloatingPane() {
+        mutateCurrentTab(() -> currentTab().nextFloatingPane());
+    }
+
+    public void toggleActiveFloating() {
+        mutateCurrentTab(() -> currentTab().toggleActiveFloating());
+    }
+
+    // Run a structural change on the current tab and bump the layout version so the next frame
+    // recomposites. No-op when no tab is left.
+    private void mutateCurrentTab(Runnable change) {
+        if (isEmpty()) {
+            return;
+        }
+        change.run();
+        layoutVersion++;
+    }
+
+    public void closeActivePane() {
+        TerminalPane active = activePane();
+        if (active != null) {
+            closePane(active);
+        }
+    }
+
+    /**
+     * Closes a specific pane, wherever it lives. Driven both by the key-bound close (via
+     * {@link #closeActivePane()}) and by a pane whose process exited on its own. Drops the owning
+     * tab if it becomes empty, and fires {@link #setOnEmpty} when the last pane is gone. Must run on
+     * the FX thread.
+     */
+    public void closePane(TerminalPane pane) {
+        for (int i = 0; i < tabs.size(); i++) {
+            Tab tab = tabs.get(i);
+            if (tab.closePane(pane)) {
+                if (tab.isEmpty()) {
+                    // Closing a tab's last pane closes the tab. Keep currentTabIndex pointing at the
+                    // same tab (or clamp it when the current/last tab went away).
+                    tabs.remove(i);
+                    if (i < currentTabIndex) {
+                        currentTabIndex--;
+                    } else if (currentTabIndex >= tabs.size()) {
+                        currentTabIndex = Math.max(0, tabs.size() - 1);
+                    }
+                }
+                layoutVersion++;
+                if (isEmpty()) {
+                    onEmpty.run();
+                }
+                return;
+            }
+        }
+    }
+
+    public void newTab() {
+        // Open the new tab in the currently active pane's working directory, so it lands where the
+        // user currently is rather than always in home.
+        TerminalPane active = activePane();
+        String workingDirectory = active != null ? active.currentWorkingDirectory() : null;
+        tabs.add(new Tab(config, metrics, workingDirectory, this::closePane));
+        currentTabIndex = tabs.size() - 1;
+        layoutVersion++;
+    }
+
+    public void nextTab() {
+        if (tabs.size() > 1) {
+            currentTabIndex = (currentTabIndex + 1) % tabs.size();
+            layoutVersion++;
+        }
+    }
+
+    public void previousTab() {
+        if (tabs.size() > 1) {
+            currentTabIndex = (currentTabIndex - 1 + tabs.size()) % tabs.size();
+            layoutVersion++;
+        }
+    }
+
+    public void close() {
+        for (Tab tab : tabs) {
+            tab.close();
+        }
+        tabs.clear();
+    }
+
+    /**
+     * Signals and reaps every pane's shell process across all tabs, without tearing down render
+     * state. Intended for a JVM shutdown hook (SIGTERM/SIGINT/SIGHUP), so child shells get the
+     * configured close signal instead of being orphaned when jprototerm itself is killed. Safe to
+     * call off the FX thread and idempotent; see {@link TerminalPane#terminateSession()}.
+     */
+    public void terminateSessions() {
+        for (Tab tab : List.copyOf(tabs)) {
+            tab.terminateSessions();
+        }
+    }
+
+    private Tab currentTab() {
+        return tabs.get(currentTabIndex);
+    }
+
+    private List<TerminalPane> currentPanes() {
+        return tabs.isEmpty() ? List.of() : currentTab().panes();
+    }
+
+    private boolean isActive(TerminalPane pane) {
+        return !tabs.isEmpty() && currentTab().isActive(pane);
+    }
+
+    private void focus(TerminalPane pane) {
+        if (!tabs.isEmpty() && currentTab().focus(pane)) {
+            layoutVersion++;
+        }
+    }
+
+    // ---- Rendering ------------------------------------------------------------------
+
+    public void render() {
+        sweepHiddenPanes();
+        switch (nextFrameType()) {
+            case IDLE -> { }
+            case LAYOUT -> renderLayoutFrame();
+            case CONTENT -> renderContentFrame();
+        }
+    }
+
+    // Free the backbuffer of any pane that has been off-screen past the grace period, and re-arm the
+    // timer for newly hidden panes. The next layout frame rebuilds a released pane (paintFull goes
+    // through ensure()), so showing a tab again is the only cost. Skips entirely once everything that
+    // can be hidden is already released and the layout hasn't changed, so an idle multi-tab window
+    // does no per-frame work here.
+    private void sweepHiddenPanes() {
+        if (layoutVersion == lastSweepLayoutVersion && hiddenSince.isEmpty()) {
+            return;
+        }
+        lastSweepLayoutVersion = layoutVersion;
+
+        // Fast path: a single tab compositing all of its panes has nothing off-screen.
+        if (tabs.size() <= 1 && (tabs.isEmpty() || !currentTab().hasHiddenPanes())) {
+            hiddenSince.clear();
+            released.clear();
+            return;
+        }
+
+        Set<TerminalPane> visible = new HashSet<>(currentPanes());
+        Set<TerminalPane> live = new HashSet<>();
+        long now = System.nanoTime();
+        for (Tab tab : tabs) {
+            for (TerminalPane pane : tab.allPanes()) {
+                live.add(pane);
+                if (visible.contains(pane)) {
+                    hiddenSince.remove(pane);
+                    released.remove(pane);
+                } else if (!released.contains(pane)) {
+                    Long since = hiddenSince.putIfAbsent(pane, now);
+                    if (since != null && now - since >= RELEASE_DELAY_NANOS) {
+                        pane.releaseRenderResources();
+                        released.add(pane);
+                        hiddenSince.remove(pane);
+                    }
+                }
+            }
+        }
+        // Forget panes that have since closed.
+        hiddenSince.keySet().retainAll(live);
+        released.retainAll(live);
+    }
+
+    // Classify this frame and commit the change trackers. A layout change (size, font,
+    // tab/pane set, z-order, active pane) needs a full recomposite; otherwise a change to the
+    // current tab's content version repaints only the panes that changed; otherwise nothing
+    // changed and the frame is idle.
+    private FrameType nextFrameType() {
+        double width = canvas.getWidth();
+        double height = canvas.getHeight();
+        long contentVersion = tabs.isEmpty() ? 0 : currentTab().contentVersion();
+
+        boolean layoutChanged = width != lastWidth || height != lastHeight
+                || metrics.fontSize() != lastFontSize || !Objects.equals(metrics.fontFamily(), lastFontFamily)
+                || layoutVersion != lastLayoutVersion;
+        boolean contentChanged = contentVersion != lastContentVersion;
+
+        lastWidth = width;
+        lastHeight = height;
+        lastFontFamily = metrics.fontFamily();
+        lastFontSize = metrics.fontSize();
+        lastLayoutVersion = layoutVersion;
+        lastContentVersion = contentVersion;
+
+        if (layoutChanged) {
+            return FrameType.LAYOUT;
+        }
+        if (contentChanged) {
+            return FrameType.CONTENT;
+        }
+        return FrameType.IDLE;
+    }
+
+    // Full recomposite onto the retained canvas: lay the tab out, clear to the gap colour,
+    // draw the tab strip, then paint every pane bottom-to-top (panes() puts the active
+    // floating pane last == on top).
+    private void renderLayoutFrame() {
+        double topInset = tabs.size() > 1 ? TAB_BAR_HEIGHT : 0.0;
+        if (!tabs.isEmpty()) {
+            currentTab().layout(canvas.getWidth(), canvas.getHeight(), topInset);
+        }
+        List<TerminalPane> panes = currentPanes();
+        // Sync each pane's ghostty grid to its (possibly new) bounds; a no-op when unchanged.
+        for (TerminalPane pane : panes) {
+            pane.fitToBounds();
+        }
+
+        GraphicsContext gc = beginFrame();
+        paneContentVersion.keySet().retainAll(panes);
+        gc.setFill(GAP_BACKGROUND);
+        gc.fillRect(0, 0, canvas.getWidth(), canvas.getHeight());
+        if (topInset > 0.0) {
+            drawTabBar(gc, canvas.getWidth(), topInset);
+        }
+        for (TerminalPane pane : panes) {
+            paneContentVersion.put(pane, pane.paintFull(gc, isActive(pane)));
+        }
+        imageOverlay.sync(panes);
+    }
+
+    // Repaint just the panes whose content changed, directly on the retained canvas. Each pane
+    // clips itself to its rect minus the panes above it, so a lower pane's repaint can't bleed
+    // over one stacked on top — no restore pass needed. Bounds and grids can't have changed
+    // without a layout frame, so a content frame reuses the existing layout untouched.
+    private void renderContentFrame() {
+        List<TerminalPane> panes = currentPanes();
+        GraphicsContext gc = beginFrame();
+
+        for (TerminalPane pane : panes) {
+            Long drawn = paneContentVersion.get(pane);
+            if (drawn != null && drawn == pane.contentVersion()) {
+                continue;
+            }
+            paneContentVersion.put(pane, pane.paintIncremental(gc, isActive(pane)));
+            imageOverlay.updatePane(pane);
+        }
+    }
+
+    private GraphicsContext beginFrame() {
+        GraphicsContext gc = canvas.getGraphicsContext2D();
+        gc.setFontSmoothingType(FontSmoothingType.LCD); // the per-cell renderer relies on LCD
+        return gc;
+    }
+
+    // Thin tab strip: one equal-width segment per tab, the current one highlighted, with a
+    // small 1-based number centred in each segment.
+    private void drawTabBar(GraphicsContext gc, double width, double barHeight) {
+        int count = tabs.size();
+        Font barFont = Font.font(metrics.fontFamily(), Math.max(9.0, Math.min(13.0, barHeight * 0.62)));
+        gc.setFont(barFont);
+        gc.setFontSmoothingType(FontSmoothingType.GRAY);
+        gc.setTextAlign(TextAlignment.CENTER);
+        gc.setTextBaseline(VPos.CENTER);
+
+        double gap = 1.0;
+        double segmentWidth = width / count;
+        for (int i = 0; i < count; i++) {
+            double x = i * segmentWidth;
+            boolean current = i == currentTabIndex;
+            gc.setFill(current ? Color.rgb(45, 55, 72) : Color.rgb(22, 24, 28));
+            gc.fillRect(x, 0.0, segmentWidth - gap, barHeight);
+            gc.setFill(current ? TAB_TEXT : Color.rgb(128, 136, 148));
+            gc.fillText(Integer.toString(i + 1), x + (segmentWidth - gap) / 2.0, barHeight / 2.0);
+        }
+
+        // Restore the defaults the cell renderer relies on (left-aligned, baseline, LCD).
+        gc.setTextAlign(TextAlignment.LEFT);
+        gc.setTextBaseline(VPos.BASELINE);
+        gc.setFontSmoothingType(FontSmoothingType.LCD);
+    }
+
+    // ---- Input ----------------------------------------------------------------------
+
+    private void handleMousePressed(MouseEvent event) {
+        canvas.requestFocus();
+        TerminalPane pane = paneAt(event.getX(), event.getY());
+        if (pane == null) {
+            return;
+        }
+
+        focus(pane);
+        pressedButton = mouseButton(event);
+        mouseButtonPressed = true;
+        MouseTarget target = mouseTarget(pane);
+        if (target == null) {
+            return;
+        }
+        send(pane, target, MouseInput.press(pressedButton, localX(event.getX(), pane, target), localY(event.getY(), pane, target), modifiers(event)), true, event);
+    }
+
+    private void handleMouseReleased(MouseEvent event) {
+        TerminalPane pane = paneAt(event.getX(), event.getY());
+        if (pane == null) {
+            pane = activePane(); // released outside every pane (e.g. mid-drag): route to the active one
+        }
+
+        MouseButton button = pressedButton == MouseButton.UNKNOWN ? mouseButton(event) : pressedButton;
+        MouseTarget target = pane == null ? null : mouseTarget(pane);
+        if (target != null) {
+            send(pane, target, MouseInput.release(button, localX(event.getX(), pane, target), localY(event.getY(), pane, target), modifiers(event)), false, event);
+        }
+        mouseButtonPressed = false;
+        pressedButton = MouseButton.UNKNOWN;
+    }
+
+    private void handleMouseDragged(MouseEvent event) {
+        TerminalPane pane = paneAt(event.getX(), event.getY());
+        if (pane == null) {
+            pane = activePane(); // dragged outside every pane: route to the active one
+        }
+        if (pane == null) {
+            return;
+        }
+
+        MouseButton button = pressedButton == MouseButton.UNKNOWN ? mouseButton(event) : pressedButton;
+        MouseTarget target = mouseTarget(pane);
+        if (target == null) {
+            return;
+        }
+        send(pane, target, MouseInput.drag(button, localX(event.getX(), pane, target), localY(event.getY(), pane, target), modifiers(event)), true, event);
+    }
+
+    private void handleMouseMoved(MouseEvent event) {
+        TerminalPane pane = paneAt(event.getX(), event.getY());
+        if (pane == null) {
+            return;
+        }
+
+        MouseTarget target = mouseTarget(pane);
+        if (target == null) {
+            return;
+        }
+        send(pane, target, MouseInput.motion(localX(event.getX(), pane, target), localY(event.getY(), pane, target), modifiers(event)), mouseButtonPressed, event);
+    }
+
+    private void handleScroll(ScrollEvent event) {
+        TerminalPane pane = paneAt(event.getX(), event.getY());
+        if (pane == null) {
+            return;
+        }
+
+        canvas.requestFocus();
+        focus(pane);
+        int direction = scrollDirection(event);
+        if (direction == 0) {
+            return;
+        }
+
+        MouseButton wheelButton = direction > 0 ? MouseButton.FOUR : MouseButton.FIVE;
+        int rows = scrollRows(event);
+        MouseTarget target = mouseTarget(pane);
+        boolean sent = false;
+        if (target != null) {
+            // The wheel sends one button press per scrolled row; resolve the position once.
+            double ex = localX(event.getX(), pane, target);
+            double ey = localY(event.getY(), pane, target);
+            KeyModifiers modifiers = modifiers(event);
+            for (int i = 0; i < rows; i++) {
+                if (!send(pane, target, MouseInput.press(wheelButton, ex, ey, modifiers), mouseButtonPressed, event)) {
+                    break;
+                }
+                sent = true;
+            }
+        }
+        if (!sent) {
+            // Not consumed by the app (e.g. mouse reporting off): scroll the local viewport.
+            pane.scrollViewport(direction > 0 ? -rows : rows);
+            event.consume();
+        }
+    }
+
+    // Forward an already-positioned mouse event to the pane, consuming it if the pane (i.e.
+    // the app running in it) acted on it. Returns whether it was sent.
+    private boolean send(TerminalPane pane, MouseTarget target, MouseInput input, boolean anyButtonPressed, InputEvent event) {
+        boolean sent = pane.sendMouse(input, target.size(), anyButtonPressed);
+        if (sent) {
+            event.consume();
+        }
+        return sent;
+    }
+
+    private TerminalPane paneAt(double x, double y) {
+        List<TerminalPane> panes = currentPanes();
+        for (int i = panes.size() - 1; i >= 0; i--) {
+            TerminalPane pane = panes.get(i);
+            if (x >= pane.x() && x < pane.x() + pane.width() && y >= pane.y() && y < pane.y() + pane.height()) {
+                return pane;
+            }
+        }
+        return null;
+    }
+
+    private MouseTarget mouseTarget(TerminalPane pane) {
+        if (pane.width() <= 2 * TerminalMetrics.PADDING || pane.height() <= 2 * TerminalMetrics.PADDING) {
+            return null;
+        }
+
+        int columns = metrics.columnsFor(pane.width());
+        int rows = metrics.rowsFor(pane.height());
+        long cellWidth = Math.max(1L, Math.round(metrics.cellWidth()));
+        long cellHeight = Math.max(1L, Math.round(metrics.lineHeight()));
+        long screenWidth = Math.max(1L, Math.round(columns * metrics.cellWidth()));
+        long screenHeight = Math.max(1L, Math.round(rows * metrics.lineHeight()));
+        return new MouseTarget(MouseEncoderSize.of(screenWidth, screenHeight, cellWidth, cellHeight), screenWidth, screenHeight);
+    }
+
+    // Resolve a canvas-space pointer position to a pane-local pixel coordinate, clamped to
+    // the pane's reported screen size (what ghostty's mouse encoder expects).
+    private static double localX(double canvasX, TerminalPane pane, MouseTarget target) {
+        return clamp(canvasX - pane.x() - TerminalMetrics.PADDING, 0.0, target.screenWidth() - 1.0);
+    }
+
+    private static double localY(double canvasY, TerminalPane pane, MouseTarget target) {
+        return clamp(canvasY - pane.y() - TerminalMetrics.PADDING, 0.0, target.screenHeight() - 1.0);
+    }
+
+    private static double clamp(double value, double min, double max) {
+        return Math.max(min, Math.min(max, value));
+    }
+
+    private static KeyModifiers modifiers(MouseEvent event) {
+        return KeyModifiers.of(event.isShiftDown(), event.isControlDown(), event.isAltDown(), event.isMetaDown());
+    }
+
+    private static KeyModifiers modifiers(ScrollEvent event) {
+        return KeyModifiers.of(event.isShiftDown(), event.isControlDown(), event.isAltDown(), event.isMetaDown());
+    }
+
+    private static int scrollRows(ScrollEvent event) {
+        double rows;
+        if (event.getTextDeltaYUnits() == VerticalTextScrollUnits.LINES && event.getTextDeltaY() != 0.0) {
+            rows = Math.abs(event.getTextDeltaY());
+        } else if (event.getTextDeltaYUnits() == VerticalTextScrollUnits.PAGES && event.getTextDeltaY() != 0.0) {
+            rows = Math.abs(event.getTextDeltaY()) * 24.0;
+        } else if (event.getMultiplierY() > 0.0) {
+            rows = Math.abs(event.getDeltaY()) / event.getMultiplierY();
+        } else {
+            rows = Math.abs(event.getDeltaY()) / 40.0;
+        }
+        return Math.max(1, Math.min(64, (int) Math.ceil(rows)));
+    }
+
+    private static int scrollDirection(ScrollEvent event) {
+        if (event.getDeltaY() != 0.0) {
+            return event.getDeltaY() > 0.0 ? 1 : -1;
+        }
+        if (event.getTextDeltaYUnits() != VerticalTextScrollUnits.NONE && event.getTextDeltaY() != 0.0) {
+            return event.getTextDeltaY() > 0.0 ? 1 : -1;
+        }
+        return 0;
+    }
+
+    private static MouseButton mouseButton(MouseEvent event) {
+        return switch (event.getButton()) {
+            case PRIMARY -> MouseButton.LEFT;
+            case SECONDARY -> MouseButton.RIGHT;
+            case MIDDLE -> MouseButton.MIDDLE;
+            default -> MouseButton.UNKNOWN;
+        };
+    }
+
+    // What one render() pass should do, decided from the change trackers in nextFrame().
+    private enum FrameType {
+        IDLE,     // nothing changed since the last frame
+        LAYOUT,   // geometry/font/tab/pane set changed: clear and repaint everything
+        CONTENT   // only terminal content changed: repaint the panes that changed
+    }
+
+    private record MouseTarget(MouseEncoderSize size, long screenWidth, long screenHeight) {
+    }
+}

src/main/java/com/gregor/jprototerm/Daemon.java

@@ -0,0 +1,183 @@
+package com.gregor.jprototerm;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.net.StandardProtocolFamily;
+import java.net.UnixDomainSocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.channels.ServerSocketChannel;
+import java.nio.channels.SocketChannel;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.attribute.PosixFilePermissions;
+
+/**
+ * Single-instance server and its thin client, over a per-user Unix domain socket. The server hosts
+ * every window in one JVM (see {@link WindowManager}); a client invocation just asks it to open a
+ * window in the client's working directory and exits, so the window appears without paying cold
+ * JVM/JavaFX/GL startup.
+ *
+ * <p>Protocol is deliberately trivial: the client writes one UTF-8 line — the absolute working
+ * directory — and the server replies {@code OK\n}. The socket lives under {@code XDG_RUNTIME_DIR}
+ * (mode 0700), so only the owning user can connect.
+ */
+public final class Daemon {
+    // One request is a single line holding a filesystem path; anything bigger is bogus.
+    private static final int MAX_REQUEST_BYTES = 4096;
+    // The accept loop is single-threaded, so a client that stalls must not wedge the daemon.
+    private static final long READ_TIMEOUT_NANOS = 5_000_000_000L;
+
+    private Daemon() {
+    }
+
+    /** Runs the server: brings up the toolkit, binds the socket, and serves window-open requests. */
+    public static void run() {
+        Path socket = socketPath();
+        try {
+            Files.createDirectories(socket.getParent());
+            secureDir(socket.getParent());
+        } catch (IOException ex) {
+            System.err.println("jprototerm: cannot secure socket dir " + socket.getParent() + ": " + ex.getMessage());
+            return;
+        }
+
+        WindowManager manager = WindowManager.start(WindowManager.Mode.DAEMON);
+
+        try (ServerSocketChannel server = bind(socket)) {
+            while (true) {
+                try {
+                    handle(server.accept(), manager);
+                } catch (IOException ex) {
+                    System.err.println("jprototerm: connection error: " + ex.getMessage());
+                }
+            }
+        } catch (IOException ex) {
+            System.err.println("jprototerm: daemon socket error: " + ex.getMessage());
+        }
+    }
+
+    /**
+     * Client side: connect to a running daemon and ask it to open a window in {@code workingDirectory}.
+     * Returns {@code true} if the daemon handled it, {@code false} if none is reachable (the caller
+     * then falls back to a standalone in-process window).
+     */
+    public static boolean tryClient(String workingDirectory) {
+        Path socket = socketPath();
+        if (!Files.exists(socket)) {
+            return false;
+        }
+        try (SocketChannel channel = SocketChannel.open(UnixDomainSocketAddress.of(socket))) {
+            channel.write(ByteBuffer.wrap((workingDirectory + "\n").getBytes(StandardCharsets.UTF_8)));
+            // Best-effort wait for the ack so we don't race ahead of the window opening.
+            channel.read(ByteBuffer.allocate(16));
+            return true;
+        } catch (IOException ex) {
+            return false; // no daemon, or a stale socket file — fall back to standalone
+        }
+    }
+
+    private static ServerSocketChannel bind(Path socket) throws IOException {
+        UnixDomainSocketAddress address = UnixDomainSocketAddress.of(socket);
+        ServerSocketChannel channel = ServerSocketChannel.open(StandardProtocolFamily.UNIX);
+        try {
+            channel.bind(address);
+            return channel;
+        } catch (IOException firstTry) {
+            // The path is taken. If a live daemon answers, this invocation lost the race; otherwise
+            // it's a stale socket from a crashed daemon, so remove it and rebind.
+            if (tryClient0(socket)) {
+                channel.close();
+                System.err.println("jprototerm: a daemon is already running");
+                System.exit(0);
+            }
+            Files.deleteIfExists(socket);
+            channel.bind(address);
+            return channel;
+        }
+    }
+
+    /** A bare connect probe used by {@link #bind} to tell a live daemon from a stale socket file. */
+    private static boolean tryClient0(Path socket) {
+        try (SocketChannel channel = SocketChannel.open(UnixDomainSocketAddress.of(socket))) {
+            return true;
+        } catch (IOException ex) {
+            return false;
+        }
+    }
+
+    private static void handle(SocketChannel connection, WindowManager manager) throws IOException {
+        try (connection) {
+            String workingDirectory = readLine(connection);
+            manager.openWindow(workingDirectory == null || workingDirectory.isBlank()
+                    ? null
+                    : workingDirectory.trim());
+            connection.configureBlocking(true);
+            connection.write(ByteBuffer.wrap("OK\n".getBytes(StandardCharsets.UTF_8)));
+        }
+    }
+
+    // Reads the request line non-blocking with a deadline and a size cap: the accept loop is
+    // single-threaded, so a client that stalls or never sends a newline must fail the connection
+    // (an IOException logged by run()) rather than wedge the daemon or grow the buffer unbounded.
+    private static String readLine(SocketChannel channel) throws IOException {
+        channel.configureBlocking(false);
+        long deadline = System.nanoTime() + READ_TIMEOUT_NANOS;
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        ByteBuffer buffer = ByteBuffer.allocate(4096);
+        while (true) {
+            int n = channel.read(buffer);
+            if (n > 0) {
+                buffer.flip();
+                while (buffer.hasRemaining()) {
+                    byte b = buffer.get();
+                    if (b == '\n') {
+                        return out.toString(StandardCharsets.UTF_8);
+                    }
+                    out.write(b);
+                    if (out.size() > MAX_REQUEST_BYTES) {
+                        throw new IOException("request line too long");
+                    }
+                }
+                buffer.clear();
+            } else if (n == -1) {
+                return out.size() == 0 ? null : out.toString(StandardCharsets.UTF_8);
+            } else {
+                if (System.nanoTime() >= deadline) {
+                    throw new IOException("request timed out");
+                }
+                try {
+                    Thread.sleep(5);
+                } catch (InterruptedException ex) {
+                    Thread.currentThread().interrupt();
+                    throw new IOException("interrupted while reading request");
+                }
+            }
+        }
+    }
+
+    private static Path socketPath() {
+        String runtimeDir = System.getenv("XDG_RUNTIME_DIR");
+        Path dir = runtimeDir != null && !runtimeDir.isBlank()
+                ? Path.of(runtimeDir, "jprototerm")
+                : Path.of("/tmp", "jprototerm-" + System.getProperty("user.name", "user"));
+        return dir.resolve("daemon.sock");
+    }
+
+    // Make the socket dir private, and refuse to use it if it is not ours. The /tmp fallback
+    // path is predictable, so another user could have pre-created it (the classic /tmp race);
+    // binding a socket inside a directory someone else owns would hand them control of it.
+    private static void secureDir(Path dir) throws IOException {
+        try {
+            Files.setPosixFilePermissions(dir, PosixFilePermissions.fromString("rwx------"));
+        } catch (UnsupportedOperationException ignored) {
+            return; // not a POSIX filesystem: nothing more we can check
+        }
+        String owner = Files.getOwner(dir, LinkOption.NOFOLLOW_LINKS).getName();
+        String user = System.getProperty("user.name");
+        if (!owner.equals(user)) {
+            throw new IOException(dir + " is owned by '" + owner + "', not '" + user + "'");
+        }
+    }
+}

src/main/java/com/gregor/jprototerm/GlyphCache.java

@@ -0,0 +1,104 @@
+package com.gregor.jprototerm;
+
+import javafx.scene.SnapshotParameters;
+import javafx.scene.canvas.Canvas;
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.image.PixelReader;
+import javafx.scene.image.WritableImage;
+import javafx.scene.paint.Color;
+import javafx.scene.text.Font;
+import javafx.scene.text.FontSmoothingType;
+import javafx.scene.text.Text;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Rasterized glyph alpha masks for one window's font, shared by every pane's renderer. The atlas is
+ * a pure function of the window's {@link TerminalMetrics} (font family/size, snapped cell geometry,
+ * baseline), and all panes in a window observe the same metrics, so a single shared cache lets N
+ * panes reuse one copy of each glyph instead of each rasterizing and retaining its own. It also
+ * means a pane whose backbuffer was released (see {@link GhosttyTerminalRenderer}) does not have to
+ * re-rasterize glyphs when it is shown again.
+ *
+ * <p>Rasterizing goes through JavaFX ({@link Canvas#snapshot}), so {@link #glyph} must be called on
+ * the FX thread — which is where all rendering happens. The cache self-invalidates when the metrics
+ * change (e.g. a font switch): the next lookup notices and clears.
+ */
+final class GlyphCache {
+    record Glyph(int width, int height, byte[] alpha) {
+    }
+
+    // Bounds the atlas so pathological glyph diversity (e.g. a dump of distinct CJK/emoji cells)
+    // can't grow it without limit; on overflow it clears and rebuilds on demand, like any
+    // metrics change.
+    private static final int MAX_GLYPHS = 4096;
+
+    private final TerminalMetrics metrics;
+    private final Map<String, Glyph> glyphs = new HashMap<>();
+    // The metrics snapshot the cached glyphs were rasterized for; a mismatch clears the cache.
+    private Font font;
+    private int cellWidth;
+    private int lineHeight;
+    private double baseline;
+
+    GlyphCache(TerminalMetrics metrics) {
+        this.metrics = metrics;
+    }
+
+    Glyph glyph(String text) {
+        ensureCurrent();
+        Glyph cached = glyphs.get(text);
+        if (cached != null) {
+            return cached;
+        }
+        if (glyphs.size() >= MAX_GLYPHS) {
+            glyphs.clear();
+        }
+        Glyph rendered = renderGlyph(text);
+        glyphs.put(text, rendered);
+        return rendered;
+    }
+
+    // Drop the rasterized masks if the font/cell geometry changed since they were built. Cheap to
+    // call per lookup: a no-op unless the window's metrics actually changed under us.
+    private void ensureCurrent() {
+        Font currentFont = metrics.font();
+        int currentCellWidth = Math.max(1, (int) Math.round(metrics.cellWidth()));
+        int currentLineHeight = Math.max(1, (int) Math.round(metrics.lineHeight()));
+        double currentBaseline = metrics.baselineOffset();
+        if (currentFont != font || currentCellWidth != cellWidth
+                || currentLineHeight != lineHeight || currentBaseline != baseline) {
+            font = currentFont;
+            cellWidth = currentCellWidth;
+            lineHeight = currentLineHeight;
+            baseline = currentBaseline;
+            glyphs.clear();
+        }
+    }
+
+    private Glyph renderGlyph(String value) {
+        Text measured = new Text(value);
+        measured.setFont(font);
+        int glyphWidth = Math.max(cellWidth, (int) Math.ceil(measured.getLayoutBounds().getWidth()) + 2);
+        Canvas canvas = new Canvas(glyphWidth, lineHeight);
+        GraphicsContext gc = canvas.getGraphicsContext2D();
+        gc.setFontSmoothingType(FontSmoothingType.GRAY);
+        gc.setFont(font);
+        gc.setFill(Color.WHITE);
+        gc.fillText(value, 0.0, baseline);
+
+        SnapshotParameters parameters = new SnapshotParameters();
+        parameters.setFill(Color.TRANSPARENT);
+        WritableImage snapshot = canvas.snapshot(parameters, null);
+        PixelReader reader = snapshot.getPixelReader();
+        byte[] alpha = new byte[glyphWidth * lineHeight];
+        for (int y = 0; y < lineHeight; y++) {
+            int offset = y * glyphWidth;
+            for (int x = 0; x < glyphWidth; x++) {
+                alpha[offset + x] = (byte) ((reader.getArgb(x, y) >>> 24) & 0xff);
+            }
+        }
+        return new Glyph(glyphWidth, lineHeight, alpha);
+    }
+}

src/main/java/com/gregor/jprototerm/KeyBinding.java

@@ -5,33 +5,70 @@ import javafx.scene.input.KeyEvent;
 
 import java.util.Locale;
 
-public record KeyBinding(boolean alt, boolean control, boolean shift, KeyCode code) {
+public record KeyBinding(boolean alt, boolean control, boolean shift, boolean meta, KeyCode code) {
     public static KeyBinding parse(String value) {
         boolean alt = false;
         boolean control = false;
         boolean shift = false;
+        boolean meta = false;
         KeyCode code = null;
 
         for (String part : value.split("\\+")) {
             String token = part.trim().toUpperCase(Locale.ROOT);
             switch (token) {
-                case "ALT", "META" -> alt = true;
+                case "ALT" -> alt = true;
+                case "META", "SUPER" -> meta = true;
                 case "CTRL", "CONTROL" -> control = true;
                 case "SHIFT" -> shift = true;
-                default -> code = KeyCode.getKeyCode(token);
+                default -> code = keyCode(token);
             }
         }
 
         if (code == null) {
             throw new IllegalArgumentException("Key binding has no key code: " + value);
         }
-        return new KeyBinding(alt, control, shift, code);
+        return new KeyBinding(alt, control, shift, meta, code);
     }
 
     public boolean matches(KeyEvent event) {
         return event.isAltDown() == alt
                 && event.isControlDown() == control
                 && event.isShiftDown() == shift
+                && event.isMetaDown() == meta
                 && event.getCode() == code;
     }
+
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder();
+        if (control) {
+            builder.append("CTRL+");
+        }
+        if (alt) {
+            builder.append("ALT+");
+        }
+        if (meta) {
+            builder.append("META+");
+        }
+        if (shift) {
+            builder.append("SHIFT+");
+        }
+        builder.append(code.getName().toUpperCase(Locale.ROOT).replace(' ', '_'));
+        return builder.toString();
+    }
+
+    private static KeyCode keyCode(String token) {
+        KeyCode alias = switch (token) {
+            case "GRAVE", "BACKTICK", "BACK_QUOTE", "`" -> KeyCode.BACK_QUOTE;
+            default -> null;
+        };
+        if (alias != null) {
+            return alias;
+        }
+        try {
+            return KeyCode.valueOf(token);
+        } catch (IllegalArgumentException ex) {
+            return KeyCode.getKeyCode(token);
+        }
+    }
 }

src/main/java/com/gregor/jprototerm/KeyEncoder.java

@@ -8,11 +8,25 @@ final class KeyEncoder {
     }
 
     static String encode(KeyEvent event) {
+        if (event.isControlDown() && !event.isAltDown() && !event.isMetaDown()) {
+            String control = controlSequence(event);
+            if (control != null) {
+                return control;
+            }
+        }
+
+        if (event.isAltDown() && !event.isControlDown() && !event.isMetaDown()) {
+            String alt = altSequence(event);
+            if (alt != null) {
+                return alt;
+            }
+        }
+
         KeyCode code = event.getCode();
         return switch (code) {
             case ENTER -> "\r";
             case BACK_SPACE -> "\u007f";
-            case TAB -> "\t";
+            case TAB -> event.isShiftDown() ? "\u001b[Z" : "\t";
             case ESCAPE -> "\u001b";
             case UP -> "\u001b[A";
             case DOWN -> "\u001b[B";
@@ -23,7 +37,43 @@ final class KeyEncoder {
             case DELETE -> "\u001b[3~";
             case PAGE_UP -> "\u001b[5~";
             case PAGE_DOWN -> "\u001b[6~";
+            case F1 -> "\u001bOP";
+            case F2 -> "\u001bOQ";
+            case F3 -> "\u001bOR";
+            case F4 -> "\u001bOS";
+            case F5 -> "\u001b[15~";
+            case F6 -> "\u001b[17~";
+            case F7 -> "\u001b[18~";
+            case F8 -> "\u001b[19~";
+            case F9 -> "\u001b[20~";
+            case F10 -> "\u001b[21~";
+            case F11 -> "\u001b[23~";
+            case F12 -> "\u001b[24~";
             default -> null;
         };
     }
+
+    private static String controlSequence(KeyEvent event) {
+        KeyCode code = event.getCode();
+        if (code.isLetterKey()) {
+            return String.valueOf((char) (Character.toUpperCase(code.getName().charAt(0)) - '@'));
+        }
+        return switch (code) {
+            case SPACE -> "\u0000";
+            case OPEN_BRACKET -> "\u001b";
+            case BACK_SLASH -> "\u001c";
+            case CLOSE_BRACKET -> "\u001d";
+            case DIGIT6 -> "\u001e";
+            case MINUS -> "\u001f";
+            default -> null;
+        };
+    }
+
+    private static String altSequence(KeyEvent event) {
+        KeyCode code = event.getCode();
+        if (code.isLetterKey() || code.isDigitKey()) {
+            return "\u001b" + code.getName().toLowerCase();
+        }
+        return null;
+    }
 }

src/main/java/com/gregor/jprototerm/KittyGraphicsRegistry.java

@@ -1,143 +0,0 @@
-package com.gregor.jprototerm;
-
-import javafx.scene.canvas.GraphicsContext;
-import javafx.scene.image.Image;
-
-import java.io.ByteArrayInputStream;
-import java.util.ArrayList;
-import java.util.Base64;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-public final class KittyGraphicsRegistry {
-    private final boolean enabled;
-    private final StringBuilder stream = new StringBuilder();
-    private final Map<Integer, StringBuilder> chunks = new HashMap<>();
-    private final List<Placement> placements = new ArrayList<>();
-
-    public KittyGraphicsRegistry(boolean enabled) {
-        this.enabled = enabled;
-    }
-
-    public synchronized void accept(String text) {
-        if (!enabled) {
-            return;
-        }
-        stream.append(text);
-        parseBufferedCommands();
-    }
-
-    public synchronized void draw(GraphicsContext gc, double originX, double originY, double cellWidth, double lineHeight) {
-        if (!enabled) {
-            return;
-        }
-
-        for (Placement placement : placements) {
-            double x = originX + placement.column * cellWidth;
-            double y = originY + placement.row * lineHeight;
-            double width = placement.columns <= 0 ? placement.image.getWidth() : placement.columns * cellWidth;
-            double height = placement.rows <= 0 ? placement.image.getHeight() : placement.rows * lineHeight;
-            gc.drawImage(placement.image, x, y, width, height);
-        }
-    }
-
-    public synchronized void clear() {
-        chunks.clear();
-        placements.clear();
-        stream.setLength(0);
-    }
-
-    private void parseBufferedCommands() {
-        int start;
-        while ((start = stream.indexOf("\u001b_G")) >= 0) {
-            int end = commandEnd(start + 3);
-            if (end < 0) {
-                if (start > 0) {
-                    stream.delete(0, start);
-                }
-                return;
-            }
-
-            String command = stream.substring(start + 3, end);
-            handleCommand(command);
-            stream.delete(0, end + terminatorLength(end));
-        }
-
-        if (stream.length() > 16384) {
-            stream.delete(0, stream.length() - 4096);
-        }
-    }
-
-    private int commandEnd(int from) {
-        int bell = stream.indexOf("\u0007", from);
-        int st = stream.indexOf("\u001b\\", from);
-        if (bell < 0) {
-            return st;
-        }
-        if (st < 0) {
-            return bell;
-        }
-        return Math.min(bell, st);
-    }
-
-    private int terminatorLength(int end) {
-        return stream.charAt(end) == '\u0007' ? 1 : 2;
-    }
-
-    private void handleCommand(String command) {
-        int separator = command.indexOf(';');
-        if (separator < 0) {
-            return;
-        }
-
-        Map<String, String> control = parseControl(command.substring(0, separator));
-        String payload = command.substring(separator + 1).replace("\n", "").replace("\r", "");
-
-        int id = intControl(control, "i", 1);
-        boolean more = intControl(control, "m", 0) == 1;
-        chunks.computeIfAbsent(id, ignored -> new StringBuilder()).append(payload);
-        if (more) {
-            return;
-        }
-
-        String data = chunks.remove(id).toString();
-        try {
-            byte[] bytes = Base64.getDecoder().decode(data);
-            Image image = new Image(new ByteArrayInputStream(bytes));
-            if (!image.isError()) {
-                placements.add(new Placement(
-                        image,
-                        intControl(control, "x", 0),
-                        intControl(control, "y", 0),
-                        intControl(control, "c", 0),
-                        intControl(control, "r", 0)
-                ));
-            }
-        } catch (IllegalArgumentException ignored) {
-            chunks.remove(id);
-        }
-    }
-
-    private static Map<String, String> parseControl(String text) {
-        Map<String, String> result = new HashMap<>();
-        for (String part : text.split(",")) {
-            int equals = part.indexOf('=');
-            if (equals > 0) {
-                result.put(part.substring(0, equals), part.substring(equals + 1));
-            }
-        }
-        return result;
-    }
-
-    private static int intControl(Map<String, String> control, String key, int fallback) {
-        try {
-            return Integer.parseInt(control.getOrDefault(key, String.valueOf(fallback)));
-        } catch (NumberFormatException ex) {
-            return fallback;
-        }
-    }
-
-    private record Placement(Image image, int column, int row, int columns, int rows) {
-    }
-}

src/main/java/com/gregor/jprototerm/KittyImageNode.java

@@ -0,0 +1,32 @@
+package com.gregor.jprototerm;
+
+import javafx.scene.image.Image;
+
+/**
+ * A single kitty image to display, produced by the renderer and consumed by {@link
+ * KittyImageOverlay}. Images are not painted onto the canvas; each becomes a retained
+ * {@code ImageView} node positioned over the pane. The {@code source*} fields are the region of
+ * {@link #image()} to show (in image pixels); the {@code x/y/width/height} are where to put it,
+ * in scene coordinates (the same space the pane's clip {@code Shape} lives in).
+ *
+ * <p>{@code imageId}+{@code placementId} identify the placement so the overlay can reuse the
+ * same node across frames instead of recreating it.
+ */
+record KittyImageNode(
+        long imageId,
+        long placementId,
+        Image image,
+        double sourceX,
+        double sourceY,
+        double sourceWidth,
+        double sourceHeight,
+        double x,
+        double y,
+        double width,
+        double height
+) {
+    /** Stable per-pane key for node reuse. Packs the two u32 ids without collision. */
+    long key() {
+        return (imageId << 32) | (placementId & 0xffffffffL);
+    }
+}

src/main/java/com/gregor/jprototerm/KittyImageOverlay.java

@@ -0,0 +1,151 @@
+package com.gregor.jprototerm;
+
+import javafx.geometry.Rectangle2D;
+import javafx.scene.Group;
+import javafx.scene.Node;
+import javafx.scene.image.ImageView;
+import javafx.scene.layout.Pane;
+import javafx.scene.shape.Rectangle;
+import javafx.scene.shape.Shape;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Renders kitty graphics images as retained scene-graph nodes layered over the {@link Compositor}
+ * canvas, instead of compositing them onto the canvas. Each pane gets a {@link Group} clipped to
+ * that pane's region (the same clip {@code Shape} the canvas renderer uses), and each visible
+ * image placement is an {@link ImageView} inside it, reused across frames so an unchanged image
+ * costs nothing to redraw.
+ *
+ * <p>The overlay {@link #node()} is mouse-transparent and sits above the canvas in the window's
+ * {@code StackPane}; its children use scene coordinates, which line up with the canvas because
+ * both fill the same root.
+ */
+final class KittyImageOverlay {
+    private final Pane root = new Pane();
+    private final Map<TerminalPane, PaneOverlay> overlays = new HashMap<>();
+
+    KittyImageOverlay() {
+        // Input belongs to the canvas underneath; the overlay only shows pixels.
+        root.setMouseTransparent(true);
+        root.setManaged(false);
+    }
+
+    Node node() {
+        return root;
+    }
+
+    /**
+     * Full reconcile to {@code panes} (bottom-to-top): drop overlays for panes that went away,
+     * refresh each surviving/added pane's images and clip, and order the per-pane groups to match
+     * the pane z-order. Called on layout frames, after the panes have painted.
+     */
+    void sync(List<TerminalPane> panes) {
+        Iterator<Map.Entry<TerminalPane, PaneOverlay>> it = overlays.entrySet().iterator();
+        while (it.hasNext()) {
+            Map.Entry<TerminalPane, PaneOverlay> entry = it.next();
+            if (!panes.contains(entry.getKey())) {
+                root.getChildren().remove(entry.getValue().group);
+                it.remove();
+            }
+        }
+        for (TerminalPane pane : panes) {
+            updatePane(pane);
+        }
+        // Only panes that actually have images get a group; order those to match pane z-order.
+        List<Node> ordered = new ArrayList<>(panes.size());
+        for (TerminalPane pane : panes) {
+            PaneOverlay overlay = overlays.get(pane);
+            if (overlay != null) {
+                ordered.add(overlay.group);
+            }
+        }
+        if (!root.getChildren().equals(ordered)) {
+            root.getChildren().setAll(ordered);
+        }
+    }
+
+    /**
+     * Refresh one pane's images and clip (called on content frames for each repainted pane).
+     * Creates the pane's group if this is the first time it has shown an image.
+     */
+    void updatePane(TerminalPane pane) {
+        List<KittyImageNode> images = pane.kittyImages();
+        PaneOverlay overlay = overlays.get(pane);
+        if (overlay == null) {
+            if (images.isEmpty()) {
+                return;
+            }
+            overlay = new PaneOverlay();
+            overlays.put(pane, overlay);
+            root.getChildren().add(overlay.group);
+        }
+        overlay.group.setClip(clipFor(pane));
+        reconcile(overlay, images);
+    }
+
+    private static void reconcile(PaneOverlay overlay, List<KittyImageNode> images) {
+        Set<Long> seen = new HashSet<>();
+        for (KittyImageNode node : images) {
+            long key = node.key();
+            seen.add(key);
+            ImageView view = overlay.views.get(key);
+            if (view == null) {
+                view = new ImageView();
+                view.setManaged(false);
+                view.setSmooth(true);
+                view.setPreserveRatio(false);
+                overlay.views.put(key, view);
+                overlay.group.getChildren().add(view);
+            }
+            apply(view, node);
+        }
+        if (overlay.views.size() == seen.size()) {
+            return;
+        }
+        Iterator<Map.Entry<Long, ImageView>> it = overlay.views.entrySet().iterator();
+        while (it.hasNext()) {
+            Map.Entry<Long, ImageView> entry = it.next();
+            if (!seen.contains(entry.getKey())) {
+                overlay.group.getChildren().remove(entry.getValue());
+                it.remove();
+            }
+        }
+    }
+
+    private static void apply(ImageView view, KittyImageNode node) {
+        if (view.getImage() != node.image()) {
+            view.setImage(node.image());
+        }
+        view.setViewport(new Rectangle2D(node.sourceX(), node.sourceY(), node.sourceWidth(), node.sourceHeight()));
+        view.setFitWidth(node.width());
+        view.setFitHeight(node.height());
+        view.setLayoutX(node.x());
+        view.setLayoutY(node.y());
+    }
+
+    // The pane's occlusion clip when one is set (rect minus covering panes), else the pane's
+    // plain bounds so an image can't spill outside its pane. Matches Tab's pixel snapping.
+    private static Shape clipFor(TerminalPane pane) {
+        Shape clip = pane.clip();
+        if (clip != null) {
+            return clip;
+        }
+        return new Rectangle(Math.round(pane.x()), Math.round(pane.y()), pane.width(), pane.height());
+    }
+
+    private static final class PaneOverlay {
+        private final Group group = new Group();
+        private final Map<Long, ImageView> views = new HashMap<>();
+
+        private PaneOverlay() {
+            group.setManaged(false);
+        }
+    }
+}

src/main/java/com/gregor/jprototerm/LinuxPty.java

@@ -0,0 +1,498 @@
+package com.gregor.jprototerm;
+
+import java.lang.foreign.AddressLayout;
+import java.lang.foreign.Arena;
+import java.lang.foreign.FunctionDescriptor;
+import java.lang.foreign.Linker;
+import java.lang.foreign.MemoryLayout;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.SymbolLookup;
+import java.lang.foreign.ValueLayout;
+import java.lang.invoke.MethodHandle;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/**
+ * A Linux PTY backed by libc via the Foreign Function & Memory API.
+ *
+ * <p>This replaces pty4j (which loads a JNA JNI shim). It uses
+ * {@code posix_openpt}/{@code posix_spawnp} rather than {@code fork}/{@code forkpty}:
+ * doing work between {@code fork} and {@code exec} inside a multithreaded JVM is unsafe
+ * (only async-signal-safe calls are permitted), whereas {@code posix_spawn} performs the
+ * dangerous part in libc with no Java on the stack.
+ *
+ * <p>The child gets a fresh session via {@code POSIX_SPAWN_SETSID}; it then opens the slave
+ * PTY itself (as fd 0, without {@code O_NOCTTY}) so the slave becomes its controlling
+ * terminal. glibc applies attribute flags (the setsid) before file actions, so the open
+ * happens in the new session.
+ */
+public final class LinuxPty implements AutoCloseable {
+    static final Linker LINKER = Linker.nativeLinker();
+    private static final SymbolLookup LIBC = LINKER.defaultLookup();
+    private static final ExecutorService REAPER = Executors.newCachedThreadPool(runnable -> {
+        Thread thread = new Thread(runnable, "pty-reaper");
+        thread.setDaemon(true);
+        return thread;
+    });
+
+    static final AddressLayout C_POINTER = (AddressLayout) LINKER.canonicalLayouts().get("void*");
+    static final ValueLayout.OfShort C_SHORT = (ValueLayout.OfShort) LINKER.canonicalLayouts().get("short");
+    static final ValueLayout.OfInt C_INT = (ValueLayout.OfInt) LINKER.canonicalLayouts().get("int");
+    static final ValueLayout.OfLong C_LONG = (ValueLayout.OfLong) LINKER.canonicalLayouts().get("long");
+    static final ValueLayout.OfLong C_SIZE_T = (ValueLayout.OfLong) LINKER.canonicalLayouts().get("size_t");
+
+    // Function descriptors.
+    static final FunctionDescriptor FD_INT_INT = FunctionDescriptor.of(C_INT, C_INT);
+    static final FunctionDescriptor FD_PTSNAME_R = FunctionDescriptor.of(C_INT, C_INT, C_POINTER, C_SIZE_T);
+    static final FunctionDescriptor FD_RW = FunctionDescriptor.of(C_LONG, C_INT, C_POINTER, C_SIZE_T);
+    static final FunctionDescriptor FD_IOCTL = FunctionDescriptor.of(C_INT, C_INT, C_LONG, C_POINTER);
+    static final FunctionDescriptor FD_KILL = FunctionDescriptor.of(C_INT, C_INT, C_INT);
+    static final FunctionDescriptor FD_WAITPID = FunctionDescriptor.of(C_INT, C_INT, C_POINTER, C_INT);
+    static final FunctionDescriptor FD_SPAWN = FunctionDescriptor.of(
+            C_INT, C_POINTER, C_POINTER, C_POINTER, C_POINTER, C_POINTER, C_POINTER);
+    static final FunctionDescriptor FD_FA_INIT = FunctionDescriptor.of(C_INT, C_POINTER);
+    static final FunctionDescriptor FD_FA_ADDCLOSE = FunctionDescriptor.of(C_INT, C_POINTER, C_INT);
+    static final FunctionDescriptor FD_FA_ADDDUP2 = FunctionDescriptor.of(C_INT, C_POINTER, C_INT, C_INT);
+    static final FunctionDescriptor FD_FA_ADDOPEN =
+            FunctionDescriptor.of(C_INT, C_POINTER, C_INT, C_POINTER, C_INT, C_INT);
+    static final FunctionDescriptor FD_FA_ADDCHDIR = FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER);
+    static final FunctionDescriptor FD_ATTR_SETFLAGS = FunctionDescriptor.of(C_INT, C_POINTER, C_SHORT);
+
+    // Linux constants (x86-64 / arm64).
+    private static final int O_RDWR = 0x0002;
+    private static final int O_NOCTTY = 0x0100;
+    private static final long TIOCSWINSZ = 0x5414L;
+    private static final short POSIX_SPAWN_SETSID = 0x80;
+    private static final int SIGHUP = 1;
+    private static final int SIGINT = 2;
+    private static final int SIGQUIT = 3;
+    private static final int SIGKILL = 9;
+    private static final int SIGTERM = 15;
+    private static final int WNOHANG = 1;
+
+    // struct winsize { unsigned short ws_row, ws_col, ws_xpixel, ws_ypixel; }
+    private static final MemoryLayout WINSIZE = MemoryLayout.structLayout(
+            C_SHORT.withName("ws_row"),
+            C_SHORT.withName("ws_col"),
+            C_SHORT.withName("ws_xpixel"),
+            C_SHORT.withName("ws_ypixel"));
+
+    // posix_spawn_file_actions_t / posix_spawnattr_t are opaque; over-allocate generously.
+    private static final long SPAWN_ACTIONS_SIZE = 256;
+    private static final long SPAWN_ATTR_SIZE = 512;
+
+    private static final MethodHandle TCGETPGRP = handle("tcgetpgrp", FD_INT_INT);
+    private static final MethodHandle POSIX_OPENPT = handle("posix_openpt", FD_INT_INT);
+    private static final MethodHandle GRANTPT = handle("grantpt", FD_INT_INT);
+    private static final MethodHandle UNLOCKPT = handle("unlockpt", FD_INT_INT);
+    private static final MethodHandle PTSNAME_R = handle("ptsname_r", FD_PTSNAME_R);
+    private static final MethodHandle CLOSE = handle("close", FD_INT_INT);
+    private static final MethodHandle READ = handle("read", FD_RW);
+    private static final MethodHandle WRITE = handle("write", FD_RW);
+    private static final MethodHandle IOCTL = handle("ioctl", FD_IOCTL, Linker.Option.firstVariadicArg(2));
+    private static final MethodHandle KILL = handle("kill", FD_KILL);
+    private static final MethodHandle WAITPID = handle("waitpid", FD_WAITPID);
+    private static final MethodHandle POSIX_SPAWNP = handle("posix_spawnp", FD_SPAWN);
+    private static final MethodHandle FA_INIT = handle("posix_spawn_file_actions_init", FD_FA_INIT);
+    private static final MethodHandle FA_DESTROY = handle("posix_spawn_file_actions_destroy", FD_FA_INIT);
+    private static final MethodHandle FA_ADDCLOSE = handle("posix_spawn_file_actions_addclose", FD_FA_ADDCLOSE);
+    private static final MethodHandle FA_ADDDUP2 = handle("posix_spawn_file_actions_adddup2", FD_FA_ADDDUP2);
+    private static final MethodHandle FA_ADDOPEN = handle("posix_spawn_file_actions_addopen", FD_FA_ADDOPEN);
+    private static final MethodHandle FA_ADDCHDIR = handle("posix_spawn_file_actions_addchdir_np", FD_FA_ADDCHDIR);
+    private static final MethodHandle ATTR_INIT = handle("posix_spawnattr_init", FD_FA_INIT);
+    private static final MethodHandle ATTR_DESTROY = handle("posix_spawnattr_destroy", FD_FA_INIT);
+    private static final MethodHandle ATTR_SETFLAGS = handle("posix_spawnattr_setflags", FD_ATTR_SETFLAGS);
+
+    private final Arena arena = Arena.ofShared();
+    private final MemorySegment readBuffer = arena.allocate(65536);
+    private final MemorySegment writeBuffer = arena.allocate(65536);
+    private final Object writeLock = new Object();
+    private final int masterFd;
+    private final int pid;
+    private final int closeSignal;
+    private volatile boolean closed;
+
+    private LinuxPty(int masterFd, int pid, int closeSignal) {
+        this.masterFd = masterFd;
+        this.pid = pid;
+        this.closeSignal = closeSignal;
+    }
+
+    /**
+     * Resolves a signal name (e.g. {@code "SIGTERM"}, {@code "TERM"}, {@code "SIGKILL"}) to its
+     * Linux signal number, or {@code -1} if the name is not one we recognise. Case-insensitive and
+     * tolerant of a missing {@code SIG} prefix.
+     */
+    public static int signalNumber(String name) {
+        if (name == null) {
+            return -1;
+        }
+        String normalized = name.trim().toUpperCase(java.util.Locale.ROOT);
+        if (normalized.startsWith("SIG")) {
+            normalized = normalized.substring(3);
+        }
+        return switch (normalized) {
+            case "HUP" -> SIGHUP;
+            case "INT" -> SIGINT;
+            case "QUIT" -> SIGQUIT;
+            case "KILL" -> SIGKILL;
+            case "TERM" -> SIGTERM;
+            default -> -1;
+        };
+    }
+
+    /**
+     * Opens a PTY and spawns {@code argv} attached to its slave end.
+     *
+     * @param argv command and arguments (e.g. {@code {"/bin/zsh", "-i"}})
+     * @param environment environment for the child, as KEY=VALUE pairs
+     * @param workingDirectory directory the child starts in, or {@code null} to inherit
+     * @param closeSignal signal number sent to the child on {@link #close()} (e.g. SIGTERM)
+     */
+    public static LinuxPty spawn(String[] argv, Map<String, String> environment, String workingDirectory,
+            int closeSignal) {
+        Arena setup = Arena.ofConfined();
+        try {
+            int master = check(callInt(POSIX_OPENPT, O_RDWR | O_NOCTTY), "posix_openpt");
+            try {
+                check(callInt(GRANTPT, master), "grantpt");
+                check(callInt(UNLOCKPT, master), "unlockpt");
+
+                MemorySegment nameBuf = setup.allocate(256);
+                check(callPtsnameR(master, nameBuf), "ptsname_r");
+                String slavePath = nameBuf.getString(0);
+
+                MemorySegment actions = setup.allocate(SPAWN_ACTIONS_SIZE);
+                MemorySegment attr = setup.allocate(SPAWN_ATTR_SIZE);
+                check(callInt(FA_INIT, actions), "posix_spawn_file_actions_init");
+                check(callInt(ATTR_INIT, attr), "posix_spawnattr_init");
+                try {
+                    check(callInt(ATTR_SETFLAGS, attr, POSIX_SPAWN_SETSID), "posix_spawnattr_setflags");
+
+                    if (workingDirectory != null) {
+                        MemorySegment dir = setup.allocateFrom(workingDirectory);
+                        check(callAddChdir(actions, dir), "posix_spawn_file_actions_addchdir_np");
+                    }
+                    // Open the slave as fd 0 in the new session -> controlling terminal, then fan out.
+                    MemorySegment slave = setup.allocateFrom(slavePath);
+                    check(callAddOpen(actions, 0, slave, O_RDWR, 0), "posix_spawn_file_actions_addopen");
+                    check(callAddDup2(actions, 0, 1), "posix_spawn_file_actions_adddup2");
+                    check(callAddDup2(actions, 0, 2), "posix_spawn_file_actions_adddup2");
+                    check(callAddClose(actions, master), "posix_spawn_file_actions_addclose");
+
+                    MemorySegment argvSeg = cStringArray(setup, List.of(argv));
+                    MemorySegment envpSeg = cStringArray(setup, toEnvList(environment));
+                    MemorySegment path = setup.allocateFrom(argv[0]);
+                    MemorySegment pidOut = setup.allocate(C_INT);
+
+                    int rc = callSpawn(pidOut, path, actions, attr, argvSeg, envpSeg);
+                    if (rc != 0) {
+                        throw new IllegalStateException("posix_spawnp failed for " + argv[0] + " (rc=" + rc + ")");
+                    }
+                    return new LinuxPty(master, pidOut.get(C_INT, 0), closeSignal);
+                } finally {
+                    callInt(ATTR_DESTROY, attr);
+                    callInt(FA_DESTROY, actions);
+                }
+            } catch (RuntimeException ex) {
+                callInt(CLOSE, master);
+                throw ex;
+            }
+        } finally {
+            setup.close();
+        }
+    }
+
+    /** Reads available output into {@code dst}; returns bytes read, or -1 at EOF. */
+    public int read(byte[] dst) {
+        if (closed) {
+            return -1;
+        }
+        long n = callLong(READ, masterFd, readBuffer, Math.min(dst.length, readBuffer.byteSize()));
+        if (n <= 0) {
+            return -1;
+        }
+        MemorySegment.copy(readBuffer, ValueLayout.JAVA_BYTE, 0, dst, 0, (int) n);
+        return (int) n;
+    }
+
+    /** Writes all of {@code data} to the master end. */
+    public void write(byte[] data) {
+        if (closed || data.length == 0) {
+            return;
+        }
+        synchronized (writeLock) {
+            int offset = 0;
+            while (offset < data.length) {
+                int chunk = (int) Math.min(writeBuffer.byteSize(), data.length - offset);
+                MemorySegment.copy(data, offset, writeBuffer, ValueLayout.JAVA_BYTE, 0, chunk);
+
+                long written = 0;
+                while (written < chunk) {
+                    long n = callLong(WRITE, masterFd, writeBuffer.asSlice(written), chunk - written);
+                    if (n <= 0) {
+                        throw new IllegalStateException("write to pty failed");
+                    }
+                    written += n;
+                }
+                offset += chunk;
+            }
+        }
+    }
+
+    /**
+     * Best-effort current working directory of the terminal's foreground process group, read from
+     * {@code /proc}. This tracks the directory the user is actually in (a {@code cd} in the shell,
+     * or a child program that changed dir), so a newly opened pane can start there. Falls back to
+     * the shell's own pid, and returns {@code null} if it cannot be determined.
+     */
+    public String currentWorkingDirectory() {
+        if (closed) {
+            return null;
+        }
+        int pgid = callInt(TCGETPGRP, masterFd);
+        int target = pgid > 0 ? pgid : pid;
+        try {
+            return Files.readSymbolicLink(Path.of("/proc", Integer.toString(target), "cwd")).toString();
+        } catch (IOException | RuntimeException ex) {
+            return null;
+        }
+    }
+
+    /** Resizes the terminal window. */
+    public void setWinSize(int columns, int rows) {
+        if (closed) {
+            return;
+        }
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment ws = a.allocate(WINSIZE);
+            ws.set(C_SHORT, 0, (short) rows);
+            ws.set(C_SHORT, 2, (short) columns);
+            ws.set(C_SHORT, 4, (short) 0);
+            ws.set(C_SHORT, 6, (short) 0);
+            callIoctl(masterFd, TIOCSWINSZ, ws);
+        }
+    }
+
+    @Override
+    public void close() {
+        if (!markClosed()) {
+            return;
+        }
+        closeMaster();
+        try {
+            reap();
+        } finally {
+            arena.close();
+        }
+    }
+
+    /** Send the configured close signal and close the master fd now; reap off the caller thread. */
+    public void closeDetached() {
+        if (!markClosed()) {
+            return;
+        }
+        closeMaster();
+        REAPER.submit(() -> {
+            try {
+                reap();
+            } finally {
+                arena.close();
+            }
+        });
+    }
+
+    private synchronized boolean markClosed() {
+        if (closed) {
+            return false;
+        }
+        closed = true;
+        return true;
+    }
+
+    private void closeMaster() {
+        // Note: closing the master fd does NOT wake a reader thread blocked in read() on it —
+        // the reader unblocks via EOF when the child exits and the slave end closes. The signal
+        // here usually does that; if the child ignores it, the SIGKILL escalation in reap()
+        // guarantees it shortly after.
+        callKill(pid, closeSignal);
+        callInt(CLOSE, masterFd);
+    }
+
+    private void reap() {
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment status = a.allocate(C_INT);
+            // Closing the master sends EOF/SIGHUP; an interactive shell exits promptly.
+            for (int attempt = 0; attempt < 50; attempt++) {
+                int r = callWaitpid(pid, status, WNOHANG);
+                if (r != 0) {
+                    return; // reaped, or no such child
+                }
+                if (attempt == 25) {
+                    callKill(pid, SIGKILL);
+                }
+                try {
+                    Thread.sleep(2);
+                } catch (InterruptedException ie) {
+                    Thread.currentThread().interrupt();
+                    return;
+                }
+            }
+        }
+    }
+
+    // --- typed invokeExact wrappers ---------------------------------------------------------
+
+    private static int callInt(MethodHandle handle, int arg) {
+        try {
+            return (int) handle.invokeExact(arg);
+        } catch (Throwable t) {
+            throw sneaky(t);
+        }
+    }
+
+    private static int callInt(MethodHandle handle, MemorySegment arg) {
+        try {
+            return (int) handle.invokeExact(arg);
+        } catch (Throwable t) {
+            throw sneaky(t);
+        }
+    }
+
+    private static int callInt(MethodHandle handle, MemorySegment a, short b) {
+        try {
+            return (int) handle.invokeExact(a, b);
+        } catch (Throwable t) {
+            throw sneaky(t);
+        }
+    }
+
+    private static long callLong(MethodHandle handle, int fd, MemorySegment buf, long len) {
+        try {
+            return (long) handle.invokeExact(fd, buf, len);
+        } catch (Throwable t) {
+            throw sneaky(t);
+        }
+    }
+
+    private static int callPtsnameR(int fd, MemorySegment buf) {
+        try {
+            return (int) PTSNAME_R.invokeExact(fd, buf, buf.byteSize());
+        } catch (Throwable t) {
+            throw sneaky(t);
+        }
+    }
+
+    private static int callAddChdir(MemorySegment actions, MemorySegment path) {
+        try {
+            return (int) FA_ADDCHDIR.invokeExact(actions, path);
+        } catch (Throwable t) {
+            throw sneaky(t);
+        }
+    }
+
+    private static int callAddOpen(MemorySegment actions, int fd, MemorySegment path, int oflag, int mode) {
+        try {
+            return (int) FA_ADDOPEN.invokeExact(actions, fd, path, oflag, mode);
+        } catch (Throwable t) {
+            throw sneaky(t);
+        }
+    }
+
+    private static int callAddDup2(MemorySegment actions, int fd, int newFd) {
+        try {
+            return (int) FA_ADDDUP2.invokeExact(actions, fd, newFd);
+        } catch (Throwable t) {
+            throw sneaky(t);
+        }
+    }
+
+    private static int callAddClose(MemorySegment actions, int fd) {
+        try {
+            return (int) FA_ADDCLOSE.invokeExact(actions, fd);
+        } catch (Throwable t) {
+            throw sneaky(t);
+        }
+    }
+
+    private static int callSpawn(MemorySegment pid, MemorySegment path, MemorySegment actions,
+                                 MemorySegment attr, MemorySegment argv, MemorySegment envp) {
+        try {
+            return (int) POSIX_SPAWNP.invokeExact(pid, path, actions, attr, argv, envp);
+        } catch (Throwable t) {
+            throw sneaky(t);
+        }
+    }
+
+    private static void callIoctl(int fd, long request, MemorySegment arg) {
+        try {
+            int unused = (int) IOCTL.invokeExact(fd, request, arg);
+        } catch (Throwable t) {
+            throw sneaky(t);
+        }
+    }
+
+    private static void callKill(int pid, int signal) {
+        try {
+            int unused = (int) KILL.invokeExact(pid, signal);
+        } catch (Throwable t) {
+            throw sneaky(t);
+        }
+    }
+
+    private static int callWaitpid(int pid, MemorySegment status, int options) {
+        try {
+            return (int) WAITPID.invokeExact(pid, status, options);
+        } catch (Throwable t) {
+            throw sneaky(t);
+        }
+    }
+
+    // --- helpers ----------------------------------------------------------------------------
+
+    private static MethodHandle handle(String symbol, FunctionDescriptor descriptor, Linker.Option... options) {
+        MemorySegment address = LIBC.find(symbol)
+                .orElseThrow(() -> new IllegalStateException("libc symbol not found: " + symbol));
+        return LINKER.downcallHandle(address, descriptor, options);
+    }
+
+    private static MemorySegment cStringArray(Arena arena, List<String> values) {
+        MemorySegment array = arena.allocate(C_POINTER, values.size() + 1L);
+        for (int i = 0; i < values.size(); i++) {
+            array.setAtIndex(C_POINTER, i, arena.allocateFrom(values.get(i)));
+        }
+        array.setAtIndex(C_POINTER, values.size(), MemorySegment.NULL);
+        return array;
+    }
+
+    private static List<String> toEnvList(Map<String, String> environment) {
+        List<String> out = new ArrayList<>(environment.size());
+        for (Map.Entry<String, String> entry : environment.entrySet()) {
+            out.add(entry.getKey() + "=" + entry.getValue());
+        }
+        return out;
+    }
+
+    private static int check(int rc, String what) {
+        if (rc < 0) {
+            throw new IllegalStateException(what + " failed (rc=" + rc + ")");
+        }
+        return rc;
+    }
+
+    private static RuntimeException sneaky(Throwable t) {
+        if (t instanceof RuntimeException re) {
+            return re;
+        }
+        if (t instanceof Error e) {
+            throw e;
+        }
+        return new IllegalStateException(t);
+    }
+}

src/main/java/com/gregor/jprototerm/Main.java

@@ -1,85 +1,36 @@
 package com.gregor.jprototerm;
 
-import javafx.animation.AnimationTimer;
-import javafx.application.Application;
-import javafx.scene.Scene;
-import javafx.scene.input.KeyEvent;
-import javafx.scene.layout.StackPane;
-import javafx.stage.Stage;
-
-public final class Main extends Application {
-    private TerminalWorkspace workspace;
-
-    @Override
-    public void start(Stage stage) {
-        AppConfig config = AppConfig.load();
-
-        workspace = new TerminalWorkspace(config);
-        TerminalCanvasView terminalView = new TerminalCanvasView(workspace, config);
-
-        StackPane root = new StackPane(terminalView.canvas());
-        terminalView.canvas().widthProperty().bind(root.widthProperty());
-        terminalView.canvas().heightProperty().bind(root.heightProperty());
-
-        Scene scene = new Scene(root, config.windowWidth(), config.windowHeight());
-        scene.addEventFilter(KeyEvent.KEY_PRESSED, event -> handlePressed(config, event));
-        scene.addEventFilter(KeyEvent.KEY_TYPED, event -> handleTyped(event));
-
-        new AnimationTimer() {
-            @Override
-            public void handle(long now) {
-                terminalView.render();
-            }
-        }.start();
-
-        stage.setTitle("jprototerm");
-        stage.setScene(scene);
-        stage.setOnCloseRequest(event -> {
-            workspace.close();
-        });
-        stage.show();
-    }
-
-    private void handlePressed(AppConfig config, KeyEvent event) {
-        if (config.keybindings().get("navigate_left").matches(event)) {
-            workspace.navigate(Direction.LEFT);
-            event.consume();
-        } else if (config.keybindings().get("navigate_down").matches(event)) {
-            workspace.navigate(Direction.DOWN);
-            event.consume();
-        } else if (config.keybindings().get("navigate_up").matches(event)) {
-            workspace.navigate(Direction.UP);
-            event.consume();
-        } else if (config.keybindings().get("navigate_right").matches(event)) {
-            workspace.navigate(Direction.RIGHT);
-            event.consume();
-        } else if (config.keybindings().get("toggle_floating").matches(event)) {
-            workspace.toggleFloating();
-            event.consume();
-        } else {
-            String encoded = KeyEncoder.encode(event);
-            if (encoded != null) {
-                workspace.activePane().send(encoded);
-                event.consume();
-            }
-        }
-    }
-
-    private void handleTyped(KeyEvent event) {
-        if (event.isAltDown() || event.isControlDown() || event.isMetaDown()) {
-            return;
-        }
-
-        String text = event.getCharacter();
-        if (text != null && !text.isEmpty() && text.charAt(0) >= 0x20 && text.charAt(0) != 0x7f) {
-            workspace.activePane().send(text);
-            event.consume();
-        }
+/**
+ * Entry point and mode dispatch. A bare invocation is a thin client: it hands the request to a
+ * running {@link Daemon}, or, if none is reachable, opens a single standalone window in this process
+ * (today's behavior). {@code --daemon} runs the long-lived server that hosts every window in one
+ * JVM, so client launches skip cold JVM/JavaFX/GL startup. {@code --standalone} skips daemon client
+ * mode and always opens an in-process window, which is useful while testing development builds.
+ */
+public final class Main {
+    private Main() {
     }
 
     public static void main(String[] args) {
-        System.setProperty("prism.order", "sw");
-        System.setProperty("prism.verbose", "true");
-        launch(Main.class, args);
+        // Match the renderer order the app was tuned for; honor an explicit override if present.
+        System.setProperty("prism.order", System.getProperty("prism.order", "es2,sw"));
+
+        boolean standalone = false;
+        for (String arg : args) {
+            if (arg.equals("--daemon")) {
+                Daemon.run();
+                return;
+            }
+            if (arg.equals("--standalone")) {
+                standalone = true;
+            }
+        }
+
+        String workingDirectory = System.getProperty("user.dir");
+        if (!standalone && Daemon.tryClient(workingDirectory)) {
+            return; // a running daemon opened the window
+        }
+        // No daemon reachable: fall back to a standalone window; the JVM exits when it closes.
+        WindowManager.start(WindowManager.Mode.STANDALONE).openWindow(workingDirectory);
     }
 }

src/main/java/com/gregor/jprototerm/RenderTarget.java

@@ -0,0 +1,45 @@
+package com.gregor.jprototerm;
+
+import dev.jlibghostty.KittyGraphics;
+import dev.jlibghostty.RenderStateSnapshot;
+import javafx.scene.shape.Shape;
+
+import java.util.Optional;
+
+/**
+ * The read-only view of a pane that a {@link TerminalRenderer} draws: its on-screen rect, its
+ * current render snapshot, and its kitty-graphics state. Decoupling the renderer from
+ * {@link TerminalPane} through this interface lets the renderer be swapped (e.g. a debug
+ * renderer that just outlines bounds and clip bands) and unit-tested against a synthetic
+ * target without a real terminal.
+ */
+interface RenderTarget {
+    double x();
+
+    double y();
+
+    double width();
+
+    double height();
+
+    /** Whether kitty graphics should be drawn for this target at all. */
+    boolean kittyEnabled();
+
+    Optional<KittyGraphics> kittyGraphics();
+
+    /**
+     * Incremental snapshot: only rows that changed since the last frame are populated. May be
+     * {@code null} before the first snapshot exists.
+     */
+    RenderStateSnapshot snapshot();
+
+    /** Full snapshot with every row populated, regardless of dirty state. */
+    RenderStateSnapshot snapshotFull();
+
+    /**
+     * The region this target may draw into, or {@code null} to clip to its plain rect. Set at
+     * layout time (a tiled pane gets its rect minus the floating panes that cover it), so the
+     * renderer can clip its own output and never paint over a pane on top.
+     */
+    Shape clip();
+}

src/main/java/com/gregor/jprototerm/ShellSession.java

@@ -1,86 +1,206 @@
 package com.gregor.jprototerm;
 
-import javafx.application.Platform;
-
-import java.io.IOException;
-import java.io.OutputStream;
 import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
 public final class ShellSession implements AutoCloseable {
-    private final Process process;
-    private final OutputStream stdin;
+    private final LinuxPty pty;
     private final ExecutorService reader;
     private volatile boolean closed;
 
-    private ShellSession(Process process, TerminalPane pane, KittyGraphicsRegistry graphicsRegistry) {
-        this.process = process;
-        this.stdin = process.getOutputStream();
+    private ShellSession(LinuxPty pty) {
+        this.pty = pty;
         this.reader = Executors.newSingleThreadExecutor(runnable -> {
             Thread thread = new Thread(runnable, "shell-output-reader");
             thread.setDaemon(true);
             return thread;
         });
-        reader.submit(() -> readOutput(pane, graphicsRegistry));
     }
 
-    public static ShellSession start(String shell, TerminalPane pane, KittyGraphicsRegistry graphicsRegistry) {
+    /**
+     * Starts the configured shell. {@code shellCommand} is the executable plus its arguments (e.g.
+     * {@code ["/bin/bash", "-i"]}), spawned verbatim — any interactive flag is the user's choice in
+     * config, not assumed here.
+     */
+    public static ShellSession start(List<String> shellCommand, Map<String, String> envOverride, TerminalPane pane,
+            int columns, int rows, String workingDirectory, int closeSignal) {
         try {
-            ProcessBuilder processBuilder = new ProcessBuilder(
-                    "script",
-                    "-qfec",
-                    shell + " -i",
-                    "/dev/null"
-            ).redirectErrorStream(true);
-            processBuilder.environment().put("TERM", "xterm-kitty");
-            processBuilder.environment().put("COLORTERM", "truecolor");
-            Process process = processBuilder.start();
-            return new ShellSession(process, pane, graphicsRegistry);
-        } catch (IOException ex) {
+            return spawn(shellCommand.toArray(new String[0]), envOverride, columns, rows, workingDirectory,
+                    closeSignal);
+        } catch (RuntimeException ex) {
             pane.write("failed to start shell: " + ex.getMessage() + "\r\n");
-            throw new IllegalStateException("Could not start shell " + shell, ex);
+            throw new IllegalStateException("Could not start shell " + String.join(" ", shellCommand), ex);
         }
     }
 
+    /**
+     * Starts a session whose first and only process is {@code /bin/sh -c command}, so the program
+     * runs deterministically from the start rather than being typed into an interactive shell —
+     * there is no startup/rc race to lose or mangle the input. When the process exits the pty
+     * closes and the pane auto-closes. {@code /bin/sh -c} is used (not the user's configured shell)
+     * because it is the portable way to run a command line and does not depend on shell-specific
+     * flags. {@code command} must not be null.
+     */
+    public static ShellSession startCommand(Map<String, String> envOverride, TerminalPane pane,
+            int columns, int rows, String workingDirectory, String command, int closeSignal) {
+        try {
+            return spawn(new String[] {"/bin/sh", "-c", command}, envOverride, columns, rows, workingDirectory,
+                    closeSignal);
+        } catch (RuntimeException ex) {
+            pane.write("failed to run command: " + ex.getMessage() + "\r\n");
+            throw new IllegalStateException("Could not run command: " + command, ex);
+        }
+    }
+
+    private static ShellSession spawn(String[] argv, Map<String, String> envOverride,
+            int columns, int rows, String workingDirectory, int closeSignal) {
+        Map<String, String> environment = new HashMap<>(System.getenv());
+        environment.put("TERM", "xterm-kitty");
+        environment.put("COLORTERM", "truecolor");
+        sanitizeWrapperEnvironment(environment);
+        environment.putAll(envOverride);
+
+        LinuxPty pty = LinuxPty.spawn(
+                argv,
+                environment,
+                workingDirectory != null ? workingDirectory : System.getProperty("user.home"),
+                closeSignal);
+        ShellSession session = new ShellSession(pty);
+        session.resize(columns, rows);
+        return session;
+    }
+
+    /**
+     * Strips the variables injected by the Nix launcher wrapper from the shell's
+     * environment so they do not leak into terminal subprocesses.
+     *
+     * <p>jprototerm is launched from a Nix wrapper that prepends Nix store paths to
+     * {@code LD_LIBRARY_PATH} (and adds a GL shim) so the bundled JavaFX/ghostty natives
+     * resolve. If the shell inherited that path, host programs run inside the terminal
+     * (e.g. {@code flatpak}, {@code pdftoppm}) would load the Nix copies of libraries such
+     * as freetype/fontconfig/glib, which in turn drag in the Nix glibc through their
+     * RUNPATHs and clash with the host {@code libc.so.6}. We restore the user's original
+     * {@code LD_LIBRARY_PATH}, captured by the wrapper before it prepended anything.
+     */
+    private static void sanitizeWrapperEnvironment(Map<String, String> environment) {
+        String hostLibraryPath = environment.remove("JPROTOTERM_HOST_LD_LIBRARY_PATH");
+        if (hostLibraryPath == null || hostLibraryPath.isEmpty()) {
+            environment.remove("LD_LIBRARY_PATH");
+        } else {
+            environment.put("LD_LIBRARY_PATH", hostLibraryPath);
+        }
+        // These are jprototerm's own runtime settings, not the user's shell environment.
+        environment.remove("GDK_BACKEND");
+        environment.remove("JLIBGHOSTTY_LIBRARY");
+        sanitizeJavaToolOptions(environment);
+    }
+
+    private static void sanitizeJavaToolOptions(Map<String, String> environment) {
+        String javaToolOptions = environment.get("JAVA_TOOL_OPTIONS");
+        if (javaToolOptions == null
+                || !javaToolOptions.contains("-XX:SharedArchiveFile=")
+                || !javaToolOptions.contains("/jprototerm/app")) {
+            return;
+        }
+
+        String sanitized = javaToolOptions
+                .replaceAll("(^|\\s)-XX:\\+AutoCreateSharedArchive(?=\\s|$)", " ")
+                .replaceAll("(^|\\s)-XX:SharedArchiveFile=\\S*/jprototerm/app\\S*(?=\\s|$)", " ")
+                .trim();
+        if (sanitized.isEmpty()) {
+            environment.remove("JAVA_TOOL_OPTIONS");
+        } else {
+            environment.put("JAVA_TOOL_OPTIONS", sanitized);
+        }
+    }
+
+    public void startReading(TerminalPane pane) {
+        reader.submit(() -> readOutput(pane));
+    }
+
+    /** Best-effort current working directory of the running shell, or {@code null} if unknown. */
+    public String currentWorkingDirectory() {
+        return closed ? null : pty.currentWorkingDirectory();
+    }
+
+    public void resize(int columns, int rows) {
+        if (closed) {
+            return;
+        }
+        pty.setWinSize(columns, rows);
+    }
+
     public void send(String text) {
+        send(text.getBytes(StandardCharsets.UTF_8));
+    }
+
+    public void send(byte[] bytes) {
         if (closed) {
             return;
         }
         try {
-            stdin.write(text.getBytes(StandardCharsets.UTF_8));
-            stdin.flush();
-        } catch (IOException ex) {
+            pty.write(bytes);
+        } catch (RuntimeException ex) {
             close();
         }
     }
 
-    private void readOutput(TerminalPane pane, KittyGraphicsRegistry graphicsRegistry) {
-        byte[] buffer = new byte[8192];
+    private void readOutput(TerminalPane pane) {
+        byte[] buffer = new byte[65536];
         try {
             int read;
-            while ((read = process.getInputStream().read(buffer)) != -1) {
-                String text = new String(buffer, 0, read, StandardCharsets.UTF_8);
+            while ((read = pty.read(buffer)) != -1) {
+                if (closed) {
+                    break;
+                }
+                byte[] bytes = new byte[read];
+                System.arraycopy(buffer, 0, bytes, 0, read);
+                // Feed the terminal model straight from the reader thread. terminal access is
+                // guarded by the per-terminal lock, and the render loop picks the change up on
+                // the next pulse. Avoiding a Platform.runLater hop per chunk removes a frame of
+                // latency and stops write tasks from contending with rendering on the FX thread
+                // when a TUI repaints heavily (the input-lag culprit).
+                pane.write(bytes);
+            }
+        } catch (RuntimeException ex) {
             if (!closed) {
-                    graphicsRegistry.accept(text);
-                    Platform.runLater(() -> {
+                pane.write("\r\nshell output stopped: " + ex.getMessage() + "\r\n");
+            }
+        }
+        // The stream ended without us closing the session, so the process exited on its own (the
+        // user typed `exit`, or a one-shot command pane finished). Let the pane tear itself down.
         if (!closed) {
-                            pane.write(text);
-                        }
-                    });
-                }
-            }
-        } catch (IOException ex) {
-            if (!closed) {
-                Platform.runLater(() -> pane.write("\r\nshell output stopped: " + ex.getMessage() + "\r\n"));
-            }
+            pane.handleSessionExit();
         }
     }
 
     @Override
     public void close() {
-        closed = true;
+        if (!markClosed()) {
+            return;
+        }
         reader.shutdownNow();
-        process.destroy();
+        pty.close();
+    }
+
+    /** Signal and disconnect the pty immediately, but leave child reaping to a background thread. */
+    public void closeDetached() {
+        if (!markClosed()) {
+            return;
+        }
+        reader.shutdownNow();
+        pty.closeDetached();
+    }
+
+    private synchronized boolean markClosed() {
+        if (closed) {
+            return false;
+        }
+        closed = true;
+        return true;
     }
 }

src/main/java/com/gregor/jprototerm/StartupTiming.java

@@ -0,0 +1,51 @@
+package com.gregor.jprototerm;
+
+import java.lang.management.ManagementFactory;
+
+/**
+ * Opt-in startup phase timing, enabled with {@code -Djprototerm.timing=true} (e.g. via
+ * {@code JAVA_TOOL_OPTIONS}); otherwise every method is a cheap no-op and prints nothing.
+ *
+ * <p>Each {@link #mark(String)} prints one line to stderr with the time since the previous mark and
+ * the total since JVM start, so a cold launch breaks down into its phases — toolkit/GL init vs
+ * config load vs font loading vs first frame. The anchor is the JVM's own start time (the closest
+ * proxy we have to "process start"), so the first mark includes JVM bootstrap and JavaFX toolkit
+ * init, which is usually the dominant cost.
+ */
+final class StartupTiming {
+    private static final boolean ENABLED = Boolean.getBoolean("jprototerm.timing");
+    // Epoch millis; getStartTime() is the JVM's start, the earliest timestamp we can anchor to.
+    private static final long JVM_START_MILLIS = ManagementFactory.getRuntimeMXBean().getStartTime();
+    private static long lastMillis = -1;
+    private static boolean firstFrameSeen;
+
+    private StartupTiming() {
+    }
+
+    /**
+     * Records a phase boundary, printing the delta since the previous mark and since JVM start.
+     * Synchronized because marks come from both the launcher thread and the FX thread.
+     */
+    static synchronized void mark(String phase) {
+        if (!ENABLED) {
+            return;
+        }
+        long now = System.currentTimeMillis();
+        long sinceStart = now - JVM_START_MILLIS;
+        long sinceLast = lastMillis < 0 ? sinceStart : now - lastMillis;
+        lastMillis = now;
+        System.err.printf("[timing] %-22s +%5d ms   (%5d ms since JVM start)%n", phase, sinceLast, sinceStart);
+    }
+
+    /**
+     * Records the first rendered frame exactly once, then becomes a no-op. Safe and cheap to call
+     * from the render loop every frame (it only ever touches FX-thread state).
+     */
+    static synchronized void firstFrame() {
+        if (!ENABLED || firstFrameSeen) {
+            return;
+        }
+        firstFrameSeen = true;
+        mark("first frame");
+    }
+}

src/main/java/com/gregor/jprototerm/Tab.java

@@ -0,0 +1,455 @@
+package com.gregor.jprototerm;
+
+import javafx.scene.shape.Rectangle;
+import javafx.scene.shape.Shape;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Consumer;
+import java.util.stream.Stream;
+
+/**
+ * One tab: a row of tiled panes with a group of floating panes shown over them. Floating panes
+ * are shown/hidden as a group ({@code floatingVisible}), and there is always at least one tiled
+ * pane — a floating pane is promoted if the last tiled one closes — so the layout always has a
+ * base. The {@link Compositor} owns the tabs and renders only the current one; mutating methods
+ * return whether they actually changed anything so it can bump its layout version.
+ */
+final class Tab implements AutoCloseable {
+    // Floating-pane sizing policy: a fraction of the tab's size with a floor so panes stay
+    // usable in small windows, cascaded diagonally per pane, kept off the window edge.
+    private static final double FLOATING_SIZE_FRACTION = 0.58;
+    private static final double FLOATING_MIN_WIDTH = 420.0;
+    private static final double FLOATING_MIN_HEIGHT = 260.0;
+    private static final double FLOATING_CASCADE_OFFSET = 28.0;
+    private static final double FLOATING_EDGE_MARGIN = 12.0;
+
+    private final AppConfig config;
+    private final TerminalMetrics metrics;
+    // Notified (on the FX thread) when one of this tab's panes' process exits on its own, so the
+    // compositor can close that pane and reap the tab/app if it was the last one.
+    private final Consumer<TerminalPane> onPaneExit;
+    private final List<TerminalPane> tiled = new ArrayList<>();
+    private final List<TerminalPane> floating = new ArrayList<>();
+    private boolean floatingVisible;
+    private TerminalPane active;
+    private final String initialWorkingDirectory;
+    // The floating pane to re-focus when the group is shown again, and to prefer when promoting
+    // after the last tiled pane closes.
+    private TerminalPane lastFocusedFloating;
+    // The tiled pane to re-focus when the floating group is hidden.
+    private TerminalPane lastFocusedTiled;
+    // Last laid-out size, so a newly opened pane can be created at roughly its eventual rect
+    // (and thus grid). Seeded from the configured window size for the first pane, which is
+    // opened before any layout pass runs.
+    private double lastWidth;
+    private double lastHeight;
+    private double lastTopInset;
+    // Bumped whenever one of this tab's panes changes content; the compositor reads the current
+    // tab's value each frame as an O(1) "anything to repaint?" check.
+    private final AtomicLong contentVersion = new AtomicLong();
+
+    Tab(AppConfig config, TerminalMetrics metrics, Consumer<TerminalPane> onPaneExit) {
+        this(config, metrics, null, onPaneExit);
+    }
+
+    /**
+     * Creates a tab whose first pane starts in {@code initialWorkingDirectory} (e.g. the cwd of the
+     * pane that was active when this tab was opened), or the user's home when {@code null}.
+     */
+    Tab(AppConfig config, TerminalMetrics metrics, String initialWorkingDirectory,
+            Consumer<TerminalPane> onPaneExit) {
+        this.config = config;
+        this.metrics = metrics;
+        this.onPaneExit = onPaneExit;
+        this.lastWidth = config.windowWidth();
+        this.lastHeight = config.windowHeight();
+        this.initialWorkingDirectory = initialWorkingDirectory;
+        TerminalPane first = openPane(false);
+        tiled.add(first);
+        active = first;
+    }
+
+    TerminalPane activePane() {
+        return active;
+    }
+
+    boolean isEmpty() {
+        return tiled.isEmpty() && floating.isEmpty();
+    }
+
+    long contentVersion() {
+        return contentVersion.get();
+    }
+
+    /**
+     * Panes to composite, bottom-to-top: tiled first, then (when shown) the floating group with
+     * the active floating pane on top.
+     */
+    List<TerminalPane> panes() {
+        if (!floatingVisible || floating.isEmpty()) {
+            return List.copyOf(tiled);
+        }
+        List<TerminalPane> ordered = new ArrayList<>(tiled.size() + floating.size());
+        ordered.addAll(tiled);
+        ordered.addAll(floatingOrder());
+        return List.copyOf(ordered);
+    }
+
+    // Floating panes bottom-to-top: insertion order, with the active pane moved to the top.
+    // Single source of the stacking order, so the clips assigned in assignClips() always match
+    // the compositing order in panes().
+    private List<TerminalPane> floatingOrder() {
+        List<TerminalPane> order = new ArrayList<>(floating.size());
+        for (TerminalPane pane : floating) {
+            if (pane != active) {
+                order.add(pane);
+            }
+        }
+        if (floating.contains(active)) {
+            order.add(active);
+        }
+        return order;
+    }
+
+    boolean isActive(TerminalPane pane) {
+        return pane != null && pane == active;
+    }
+
+    /** Every pane this tab owns, composited or not (tiled then floating). */
+    List<TerminalPane> allPanes() {
+        List<TerminalPane> all = new ArrayList<>(tiled.size() + floating.size());
+        all.addAll(tiled);
+        all.addAll(floating);
+        return all;
+    }
+
+    /** Whether this tab owns panes that {@link #panes()} does not currently composite. */
+    boolean hasHiddenPanes() {
+        return !floatingVisible && !floating.isEmpty();
+    }
+
+    boolean focus(TerminalPane pane) {
+        if (pane == active || !isFocusable(pane)) {
+            return false;
+        }
+        setActive(pane);
+        return true;
+    }
+
+    void layout(double width, double height, double topInset) {
+        this.lastWidth = width;
+        this.lastHeight = height;
+        this.lastTopInset = topInset;
+        double availHeight = height - topInset;
+
+        double tileWidth = width / Math.max(1, tiled.size());
+        for (int i = 0; i < tiled.size(); i++) {
+            tiled.get(i).bounds(i * tileWidth, topInset, tileWidth, availHeight);
+        }
+
+        double floatingWidth = Math.max(FLOATING_MIN_WIDTH, width * FLOATING_SIZE_FRACTION);
+        double floatingHeight = Math.max(FLOATING_MIN_HEIGHT, availHeight * FLOATING_SIZE_FRACTION);
+        for (int i = 0; i < floating.size(); i++) {
+            double offset = i * FLOATING_CASCADE_OFFSET;
+            floating.get(i).bounds(
+                    Math.min(width - floatingWidth - FLOATING_EDGE_MARGIN,
+                            ((width - floatingWidth) / 2.0) + offset),
+                    Math.min(height - floatingHeight - FLOATING_EDGE_MARGIN,
+                            topInset + ((availHeight - floatingHeight) / 2.0) + offset),
+                    floatingWidth,
+                    floatingHeight);
+        }
+
+        assignClips();
+    }
+
+    // Give each pane its clip region for the next paints, so repainting a pane on a content
+    // frame can never bleed over one stacked on top of it. Each pane is clipped to its rect
+    // minus the union of the panes above it: floating panes are clipped by the floating panes
+    // higher in the stack, and tiled panes by the whole floating group. When nothing floats,
+    // every pane clips to its plain bounds.
+    private void assignClips() {
+        if (!floatingVisible || floating.isEmpty()) {
+            allPanes().forEach(pane -> pane.setClip(null));
+            return;
+        }
+
+        // Walk the floating stack top-to-bottom, accumulating the union of the panes above
+        // each one. The topmost pane has nothing above it and keeps an unclipped bounds.
+        List<TerminalPane> order = floatingOrder();
+        Shape above = null;
+        for (int i = order.size() - 1; i >= 0; i--) {
+            TerminalPane pane = order.get(i);
+            Rectangle rect = rectOf(pane);
+            pane.setClip(above == null ? null : Shape.subtract(rect, above));
+            above = (above == null) ? rect : Shape.union(above, rect);
+        }
+
+        // `above` is now the union of every floating pane; tiled panes sit under all of them.
+        for (TerminalPane pane : tiled) {
+            pane.setClip(Shape.subtract(rectOf(pane), above));
+        }
+    }
+
+    // Match the renderer's pixel snapping (round the origin, keep width/height) so the clip
+    // lines up exactly with where the floating panes are drawn.
+    private static Rectangle rectOf(TerminalPane pane) {
+        return new Rectangle(Math.round(pane.x()), Math.round(pane.y()), pane.width(), pane.height());
+    }
+
+    boolean navigate(Direction direction) {
+        if (floating.contains(active) && navigateFloatingStack(direction)) {
+            return true;
+        }
+        TerminalPane target = focusable()
+                .filter(pane -> pane != active)
+                .filter(pane -> directionFilter(direction, active, pane))
+                .min(Comparator.comparingDouble(pane -> distance(active, pane)))
+                .orElse(null);
+        if (target != null) {
+            setActive(target);
+            return true;
+        }
+        return false;
+    }
+
+    void toggleFloating() {
+        if (floating.isEmpty()) {
+            createFloatingPane();
+            return;
+        }
+        if (floatingVisible) {
+            floatingVisible = false;
+            if (floating.contains(active)) {
+                setActive(tiled.contains(lastFocusedTiled) ? lastFocusedTiled : tiled.get(0));
+            }
+        } else {
+            floatingVisible = true;
+            setActive(floating.contains(lastFocusedFloating) ? lastFocusedFloating : floating.get(floating.size() - 1));
+        }
+    }
+
+    /** Adds a floating pane while the floating group is shown, otherwise a tiled pane. */
+    void createPane() {
+        if (floatingVisible) {
+            createFloatingPane();
+        } else {
+            TerminalPane pane = openPane(false);
+            tiled.add(pane);
+            setActive(pane);
+        }
+    }
+
+    void nextFloatingPane() {
+        if (floating.isEmpty()) {
+            createFloatingPane();
+            return;
+        }
+        floatingVisible = true;
+        int current = floating.indexOf(active); // -1 when the active pane is tiled
+        setActive(floating.get((current + 1 + floating.size()) % floating.size()));
+    }
+
+    /** Promotes the active floating pane to a tiled pane, joining the tiled row. No-op otherwise. */
+    void toggleActiveFloating() {
+        TerminalPane toggled = active;
+        if (floating.remove(toggled)) {
+            lastFocusedFloating = floating.isEmpty() ? null : floating.get(floating.size() - 1);
+            tiled.add(toggled);
+            floatingVisible = false;
+            setActive(toggled);
+        } else if (tiled.remove(toggled)) {
+            lastFocusedTiled = tiled.isEmpty() ? null : tiled.get(tiled.size() -1);
+            floating.add(toggled);
+            floatingVisible = true;
+            setActive(toggled);
+        }
+    }
+
+    /**
+     * Closes {@code closing} (the active pane on a key-bound close, or any pane whose process just
+     * exited) and re-selects the active pane only when the one that closed was active. Returns
+     * false when the pane is not in this tab. Leaves the tab empty ({@code active == null}) when its
+     * last pane closes, so the compositor can drop it.
+     */
+    boolean closePane(TerminalPane closing) {
+        boolean wasFloating = floating.remove(closing);
+        boolean wasTiled = !wasFloating && tiled.remove(closing);
+        if (!wasFloating && !wasTiled) {
+            return false; // not one of this tab's panes (already gone)
+        }
+        boolean wasActive = closing == active;
+        if (closing == lastFocusedFloating) {
+            lastFocusedFloating = null;
+        }
+        if (closing == lastFocusedTiled) {
+            lastFocusedTiled = null;
+        }
+        closing.close();
+
+        if (tiled.isEmpty() && floating.isEmpty()) {
+            active = null; // tab is now empty; the compositor drops it
+            return true;
+        }
+
+        // Always keep a tiled base: if the last tiled pane just closed, promote a floating one
+        // (preferring the last focused).
+        if (tiled.isEmpty()) {
+            TerminalPane promote = floating.contains(lastFocusedFloating) ? lastFocusedFloating : floating.get(0);
+            var promoteIndex = floating.indexOf(promote);
+            var nextFocussed = promoteIndex == 0 ? 0 : promoteIndex - 1;
+            floating.remove(promote);
+            tiled.add(promote);
+            if (promote == lastFocusedFloating) {
+                lastFocusedFloating = floating.isEmpty() ? null : floating.get(nextFocussed);
+            }
+        }
+        if (floating.isEmpty()) {
+            floatingVisible = false;
+        }
+
+        // Only the active pane closing forces a re-selection; closing a background pane (e.g. one
+        // whose process exited while another is focused) leaves focus where it is.
+        if (wasActive) {
+            setActive(wasFloating && floatingVisible
+                    ? floating.get(floating.size() - 1)
+                    : tiled.contains(lastFocusedTiled) ? lastFocusedTiled : tiled.get(0));
+        }
+        return true;
+    }
+
+    private void setActive(TerminalPane pane) {
+        active = pane;
+        if (floating.contains(pane)) {
+            lastFocusedFloating = pane;
+        } else if (tiled.contains(pane)) {
+            lastFocusedTiled = pane;
+            // A tiled pane gaining focus hides the floating group: leaving it shown while a tiled
+            // pane is active strands focus behind the overlay and disables navigation.
+            floatingVisible = false;
+        }
+    }
+
+    private void createFloatingPane() {
+        addFloating(openPane(true));
+    }
+
+    /**
+     * Opens a floating pane whose process runs {@code command} directly (auto-closing when it
+     * exits), rather than an interactive shell. Used for one-shot panes like the scrollback editor.
+     */
+    TerminalPane createFloatingPane(String command) {
+        double[] size = paneSize(true);
+        return addFloating(register(TerminalPane.createWithCommand(
+                config, metrics, this::markContentChanged, size[0], size[1], paneWorkingDirectory(), command)));
+    }
+
+    private TerminalPane addFloating(TerminalPane pane) {
+        floating.add(pane);
+        floatingVisible = true;
+        setActive(pane);
+        return pane;
+    }
+
+    private boolean navigateFloatingStack(Direction direction) {
+        if (floating.size() < 2) {
+            return false;
+        }
+        int current = floating.indexOf(active);
+        if (current < 0) {
+            return false;
+        }
+        int next = switch (direction) {
+            case LEFT, UP -> current - 1;
+            case DOWN, RIGHT -> current + 1;
+        };
+        if (next < 0 || next >= floating.size()) {
+            return false;
+        }
+        setActive(floating.get(next));
+        return true;
+    }
+
+    private boolean isFocusable(TerminalPane pane) {
+        return tiled.contains(pane) || (floatingVisible && floating.contains(pane));
+    }
+
+    private Stream<TerminalPane> focusable() {
+        return floatingVisible ? Stream.concat(tiled.stream(), floating.stream()) : tiled.stream();
+    }
+
+    private void markContentChanged() {
+        contentVersion.incrementAndGet();
+    }
+
+    private TerminalPane openPane(boolean asFloating) {
+        double[] size = paneSize(asFloating);
+        return register(TerminalPane.create(
+                config, metrics, this::markContentChanged, size[0], size[1], paneWorkingDirectory()));
+    }
+
+    private double[] paneSize(boolean asFloating) {
+        double availHeight = lastHeight - lastTopInset;
+        if (asFloating) {
+            return new double[] {
+                    Math.max(FLOATING_MIN_WIDTH, lastWidth * FLOATING_SIZE_FRACTION),
+                    Math.max(FLOATING_MIN_HEIGHT, availHeight * FLOATING_SIZE_FRACTION)};
+        }
+        // A new tiled pane joins the row, so each gets 1/(n+1) of the width.
+        return new double[] {lastWidth / (tiled.size() + 1), availHeight};
+    }
+
+    // Open a new pane in the active pane's working directory, so a split/new pane lands where the
+    // user currently is. With no active pane yet (the tab's first pane), fall back to the directory
+    // this tab was opened in. null (cwd unknown) falls back to home downstream.
+    private String paneWorkingDirectory() {
+        return active != null ? active.currentWorkingDirectory() : initialWorkingDirectory;
+    }
+
+    // Wire the pane's self-exit (process ended) back to the compositor so it gets reaped.
+    private TerminalPane register(TerminalPane pane) {
+        pane.setOnExit(() -> onPaneExit.accept(pane));
+        return pane;
+    }
+
+    private static boolean directionFilter(Direction direction, TerminalPane current, TerminalPane candidate) {
+        double currentCenterX = current.x() + current.width() / 2.0;
+        double currentCenterY = current.y() + current.height() / 2.0;
+        double candidateCenterX = candidate.x() + candidate.width() / 2.0;
+        double candidateCenterY = candidate.y() + candidate.height() / 2.0;
+
+        return switch (direction) {
+            case LEFT -> candidateCenterX < currentCenterX;
+            case DOWN -> candidateCenterY > currentCenterY;
+            case UP -> candidateCenterY < currentCenterY;
+            case RIGHT -> candidateCenterX > currentCenterX;
+        };
+    }
+
+    private static double distance(TerminalPane current, TerminalPane candidate) {
+        double dx = (current.x() + current.width() / 2.0) - (candidate.x() + candidate.width() / 2.0);
+        double dy = (current.y() + current.height() / 2.0) - (candidate.y() + candidate.height() / 2.0);
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+
+    @Override
+    public void close() {
+        tiled.forEach(TerminalPane::close);
+        floating.forEach(TerminalPane::close);
+        tiled.clear();
+        floating.clear();
+    }
+
+    /**
+     * Signals and reaps every pane's shell process without tearing down render state. Safe to call
+     * off the FX thread (see {@link TerminalPane#terminateSession()}); iterates snapshots so a
+     * concurrent close on the FX thread can't trigger a {@link java.util.ConcurrentModificationException}.
+     */
+    public void terminateSessions() {
+        List.copyOf(tiled).forEach(TerminalPane::terminateSession);
+        List.copyOf(floating).forEach(TerminalPane::terminateSession);
+    }
+}

src/main/java/com/gregor/jprototerm/TerminalCanvasView.java

@@ -1,74 +0,0 @@
-package com.gregor.jprototerm;
-
-import javafx.scene.canvas.Canvas;
-import javafx.scene.canvas.GraphicsContext;
-import javafx.scene.paint.Color;
-import javafx.scene.text.Font;
-import javafx.scene.text.FontSmoothingType;
-
-public final class TerminalCanvasView {
-    private final Canvas canvas = new Canvas();
-    private final TerminalWorkspace workspace;
-    private final AppConfig config;
-
-    public TerminalCanvasView(TerminalWorkspace workspace, AppConfig config) {
-        this.workspace = workspace;
-        this.config = config;
-        canvas.setFocusTraversable(true);
-    }
-
-    public Canvas canvas() {
-        return canvas;
-    }
-
-    public void render() {
-        double width = canvas.getWidth();
-        double height = canvas.getHeight();
-        workspace.layout(width, height);
-
-        GraphicsContext gc = canvas.getGraphicsContext2D();
-        gc.setFill(Color.rgb(16, 16, 18));
-        gc.fillRect(0, 0, width, height);
-        gc.setFontSmoothingType(FontSmoothingType.GRAY);
-
-        for (TerminalPane pane : workspace.panes()) {
-            drawPane(gc, pane);
-        }
-    }
-
-    private void drawPane(GraphicsContext gc, TerminalPane pane) {
-        gc.save();
-        gc.beginPath();
-        gc.rect(pane.x(), pane.y(), pane.width(), pane.height());
-        gc.clip();
-
-        if (pane.floating()) {
-            gc.setGlobalAlpha(0.96);
-        }
-        gc.setFill(Color.rgb(9, 10, 12));
-        gc.fillRect(pane.x(), pane.y(), pane.width(), pane.height());
-        gc.setGlobalAlpha(1.0);
-
-        gc.setStroke(workspace.isActive(pane) ? Color.rgb(87, 166, 255) : Color.rgb(52, 57, 65));
-        gc.setLineWidth(workspace.isActive(pane) ? 2.0 : 1.0);
-        gc.strokeRect(pane.x() + 0.5, pane.y() + 0.5, pane.width() - 1.0, pane.height() - 1.0);
-
-        Font font = Font.font(config.fontFamily(), config.fontSize());
-        gc.setFont(font);
-        gc.setFill(Color.rgb(225, 229, 235));
-
-        double lineHeight = Math.ceil(config.fontSize() * 1.35);
-        double left = pane.x() + 12.0;
-        double baseline = pane.y() + 18.0;
-        int maxLines = Math.max(1, (int) ((pane.height() - 24.0) / lineHeight));
-
-        String[] lines = pane.snapshotText().split("\\R", -1);
-        int start = Math.max(0, lines.length - maxLines);
-        for (int i = start; i < lines.length; i++) {
-            gc.fillText(lines[i], left, baseline + ((i - start) * lineHeight));
-        }
-
-        pane.graphicsRegistry().draw(gc, pane.x() + 12.0, pane.y() + 12.0, config.fontSize() * 0.62, lineHeight);
-        gc.restore();
-    }
-}

src/main/java/com/gregor/jprototerm/TerminalMetrics.java

@@ -0,0 +1,94 @@
+package com.gregor.jprototerm;
+
+import javafx.scene.text.Font;
+import javafx.scene.text.Text;
+
+/**
+ * Cell geometry shared by the {@link Compositor} and every {@link TerminalPane}.
+ *
+ * <p>The nominal cell width/height come from measuring the font, but a grid can't use
+ * fractional cells, so the measured size is snapped to whole (logical) pixels here — that
+ * snapping is why the value isn't purely a property of the font. The compositor owns the
+ * single instance (it holds the canvas, which is the pixel context), hands it to panes so
+ * they can turn their rect into a column/row count themselves, and re-measures it on a font
+ * change so every pane observes the new geometry through the shared reference.
+ */
+public final class TerminalMetrics {
+    /** Inset, in pixels, between a pane's edge and its content on every side. */
+    public static final double PADDING = 12.0;
+
+    private String fontFamily;
+    private double fontSize;
+    private Font font;
+    private double cellWidth;
+    private double lineHeight;
+    private double baselineOffset;
+    // One rasterized-glyph atlas per window, shared by every pane's renderer (the masks are a pure
+    // function of the font geometry below). It self-invalidates when these metrics change.
+    private final GlyphCache glyphCache = new GlyphCache(this);
+
+    public TerminalMetrics(String fontFamily, double fontSize) {
+        setFont(fontFamily, fontSize);
+    }
+
+    public void setFont(String fontFamily, double fontSize) {
+        this.fontFamily = fontFamily;
+        this.fontSize = fontSize;
+        this.font = Font.font(fontFamily, fontSize);
+        measure(font);
+    }
+
+    public String fontFamily() {
+        return fontFamily;
+    }
+
+    public double fontSize() {
+        return fontSize;
+    }
+
+    public Font font() {
+        return font;
+    }
+
+    public double cellWidth() {
+        return cellWidth;
+    }
+
+    public double lineHeight() {
+        return lineHeight;
+    }
+
+    public double baselineOffset() {
+        return baselineOffset;
+    }
+
+    /** The window's shared glyph atlas (see {@link GlyphCache}). */
+    public GlyphCache glyphCache() {
+        return glyphCache;
+    }
+
+    /** Columns that fit in a pane of the given pixel width (after subtracting the padding). */
+    public int columnsFor(double widthPx) {
+        return Math.max(1, (int) ((widthPx - 2 * PADDING) / cellWidth));
+    }
+
+    /** Rows that fit in a pane of the given pixel height (after subtracting the padding). */
+    public int rowsFor(double heightPx) {
+        return Math.max(1, (int) ((heightPx - 2 * PADDING) / lineHeight));
+    }
+
+    private void measure(Font font) {
+        Text text = new Text("┃MgÅjy");
+        text.setFont(font);
+        // Snap the cell size to whole pixels so cells tile on integer boundaries. Fractional
+        // cell metrics put every cell edge on a sub-pixel position, leaving anti-aliased
+        // seams that show up as a faint grid behind the themed cell backgrounds. Rounding
+        // leaves a few pixels of unused space at the right/bottom edge, which is fine.
+        this.lineHeight = Math.max(1.0, Math.round(text.getLayoutBounds().getHeight()));
+        this.baselineOffset = -text.getLayoutBounds().getMinY();
+
+        Text cell = new Text("M");
+        cell.setFont(font);
+        this.cellWidth = Math.max(1.0, Math.round(cell.getLayoutBounds().getWidth()));
+    }
+}

src/main/java/com/gregor/jprototerm/TerminalPane.java

@@ -1,34 +1,161 @@
 package com.gregor.jprototerm;
 
+import dev.jlibghostty.DeviceAttributes;
 import dev.jlibghostty.Ghostty;
+import dev.jlibghostty.KittyGraphics;
+import dev.jlibghostty.MouseAction;
+import dev.jlibghostty.MouseEncoder;
+import dev.jlibghostty.MouseEncoderSize;
+import dev.jlibghostty.MouseInput;
+import dev.jlibghostty.RenderState;
+import dev.jlibghostty.RenderStateSnapshot;
+import dev.jlibghostty.ScrollViewport;
 import dev.jlibghostty.Terminal;
 import dev.jlibghostty.TerminalOptions;
+import javafx.application.Platform;
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.shape.Shape;
 
-import java.util.concurrent.atomic.AtomicReference;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Supplier;
 
-public final class TerminalPane implements AutoCloseable {
+/**
+ * One terminal: owns its ghostty {@link Terminal}, the {@link ShellSession}/pty driving it,
+ * and its on-screen geometry and grid. It does not draw itself — it is a {@link RenderTarget}
+ * that a {@link TerminalRenderer} paints. {@link #paintFull}/{@link #paintIncremental} are the
+ * only rendering API exposed to the {@link Compositor}, and they just delegate to that
+ * renderer; the compositor decides z-order and which rect each pane occupies.
+ */
+public final class TerminalPane implements AutoCloseable, RenderTarget {
     private final Terminal terminal;
-    private final KittyGraphicsRegistry graphicsRegistry;
-    private final AtomicReference<String> snapshotText = new AtomicReference<>("");
-    private ShellSession session;
-    private boolean floating;
+    private final TerminalMetrics metrics;
+    private final boolean kittyEnabled;
+    // Run on every content change so the owning tab can bump its content version — the
+    // compositor's O(1) "did the current tab change?" gate.
+    private final Runnable onContentChange;
+    private final TerminalRenderer renderer;
+    private final MouseEncoder mouseEncoder = new MouseEncoder();
+    // A persistent render state (reused across frames) is what makes ghostty's per-row dirty
+    // tracking meaningful: update() accumulates dirty since the last resetDirty().
+    private final RenderState renderState = new RenderState();
+    private RenderStateSnapshot cachedSnapshot;
+    private volatile ShellSession session;
+    // Run once (on the FX thread) when this pane's process exits on its own, so the owning tab can
+    // remove it. Set by the Tab that creates the pane; null until then.
+    private Runnable onExit;
+    private boolean exited;
+    // Clip region for rendering (rect minus the panes covering this one), set at layout time;
+    // null means clip to the plain bounds. See RenderTarget#clip().
+    private Shape clip;
     private double x;
     private double y;
     private double width;
     private double height;
+    private int columns;
+    private int rows;
+    private int pixelWidth;
+    private int pixelHeight;
+    private final AtomicLong contentVersion = new AtomicLong();
+    private long snapshotVersion = -1;
 
-    private TerminalPane(Terminal terminal, KittyGraphicsRegistry graphicsRegistry) {
+    private TerminalPane(Terminal terminal, TerminalMetrics metrics, boolean kittyEnabled,
+            Runnable onContentChange, TerminalRenderer renderer, int columns, int rows) {
         this.terminal = terminal;
-        this.graphicsRegistry = graphicsRegistry;
+        this.metrics = metrics;
+        this.kittyEnabled = kittyEnabled;
+        this.onContentChange = onContentChange;
+        this.renderer = renderer;
+        this.columns = columns;
+        this.rows = rows;
     }
 
-    public static TerminalPane create(int columns, int rows, boolean kittyGraphics) {
-        Terminal terminal = Ghostty.open(TerminalOptions.of(columns, rows));
-        TerminalPane pane = new TerminalPane(terminal, new KittyGraphicsRegistry(kittyGraphics));
+    /**
+     * Opens a pane sized to fit the given pixel rect: the shared cell metrics decide how many
+     * columns and rows fit, and that grid is handed to ghostty and the shell at start-up. A
+     * non-positive size falls back to the configured default grid (used before the first
+     * layout, when no rect is known yet). The pane owns the shell session it starts and runs
+     * {@code onContentChange} on every content change. The shell starts in {@code workingDirectory}
+     * (e.g. the active pane's cwd), or the user's home when {@code null}.
+     */
+    public static TerminalPane create(AppConfig config, TerminalMetrics metrics, Runnable onContentChange,
+            double widthPx, double heightPx, String workingDirectory) {
+        TerminalPane pane = newPane(config, metrics, onContentChange, widthPx, heightPx);
+        attachOrShowError(pane, () -> ShellSession.start(config.shell(), config.envOverride(), pane,
+                pane.columns, pane.rows, workingDirectory, config.closeSignalNumber()));
+        return pane;
+    }
+
+    /**
+     * Opens a pane whose process runs {@code command} directly (via {@code /bin/sh -c}) instead of
+     * an interactive shell. The pane auto-closes when the command exits. See
+     * {@link ShellSession#startCommand}.
+     */
+    public static TerminalPane createWithCommand(AppConfig config, TerminalMetrics metrics, Runnable onContentChange,
+            double widthPx, double heightPx, String workingDirectory, String command) {
+        TerminalPane pane = newPane(config, metrics, onContentChange, widthPx, heightPx);
+        attachOrShowError(pane, () -> ShellSession.startCommand(config.envOverride(), pane,
+                pane.columns, pane.rows, workingDirectory, command, config.closeSignalNumber()));
+        return pane;
+    }
+
+    // Start the pane's process, but never let a spawn failure (e.g. a bad `shell` in config)
+    // propagate and crash window/pane creation. ShellSession has already written the error into
+    // the pane, so the pane opens showing it; with no session attached it is inert (sends are
+    // dropped) and the user closes it with the close-pane key.
+    private static void attachOrShowError(TerminalPane pane, Supplier<ShellSession> start) {
+        try {
+            pane.attach(start.get());
+        } catch (RuntimeException ex) {
+            System.err.println("jprototerm: " + ex.getMessage());
+        }
+    }
+
+    private static TerminalPane newPane(AppConfig config, TerminalMetrics metrics, Runnable onContentChange,
+            double widthPx, double heightPx) {
+        int columns = widthPx > 0 ? metrics.columnsFor(widthPx) : config.columns();
+        int rows = heightPx > 0 ? metrics.rowsFor(heightPx) : config.rows();
+        Terminal terminal = Ghostty.open(new TerminalOptions(columns, rows, config.maxScrollback()));
+        terminal.setDeviceAttributesProvider(DeviceAttributes::xtermCompatible);
+        TerminalPane pane = new TerminalPane(terminal, metrics, config.kittyGraphics(), onContentChange,
+                new GhosttyTerminalRenderer(metrics), columns, rows);
         pane.refresh();
         return pane;
     }
 
+    /** Sets the callback run when this pane's process exits on its own (see {@link #handleSessionExit}). */
+    public void setOnExit(Runnable onExit) {
+        this.onExit = onExit;
+    }
+
+    /**
+     * Called from the shell reader thread when the pty stream ends without us closing it (the
+     * process exited). Hops to the FX thread and fires {@link #onExit} once, so tab/compositor
+     * mutation happens on the thread that owns the layout.
+     */
+    void handleSessionExit() {
+        Platform.runLater(() -> {
+            if (exited) {
+                return;
+            }
+            exited = true;
+            if (onExit != null) {
+                onExit.run();
+            }
+        });
+    }
+
+    private void attach(ShellSession session) {
+        this.session = session;
+        terminal.setPtyWriter(bytes -> {
+            ShellSession current = this.session;
+            if (current != null) {
+                current.send(bytes);
+            }
+        });
+        session.startReading(this);
+    }
+
     public void write(String text) {
         synchronized (terminal) {
             terminal.write(text);
@@ -36,44 +163,149 @@ public final class TerminalPane implements AutoCloseable {
         }
     }
 
-    public void attach(ShellSession session) {
-        this.session = session;
+    public void write(byte[] bytes) {
+        synchronized (terminal) {
+            terminal.write(bytes);
+            refresh();
+        }
     }
 
     public void send(String text) {
+        scrollViewportToBottom();
         if (session != null) {
             session.send(text);
         }
     }
 
-    public String snapshotText() {
-        return snapshotText.get();
+    /**
+     * Paste text to the shell: ghostty sanitises it (stripping anything that could smuggle in
+     * control sequences) and wraps it in the bracketed-paste markers, then it goes to the pty
+     * like typed input. We always request bracketed mode — every modern shell and editor enables
+     * DECSET 2004, and the jlibghostty API does not expose querying the terminal's live mode.
+     */
+    public void paste(String text) {
+        if (text == null || text.isEmpty()) {
+            return;
+        }
+        send(Ghostty.encodePaste(text, true));
     }
 
-    public KittyGraphicsRegistry graphicsRegistry() {
-        return graphicsRegistry;
+    public boolean sendMouse(MouseInput input, MouseEncoderSize size, boolean anyButtonPressed) {
+        synchronized (terminal) {
+            mouseEncoder.syncFromTerminal(terminal);
+            mouseEncoder.setSize(size);
+            mouseEncoder.setAnyButtonPressed(anyButtonPressed);
+            mouseEncoder.setTrackLastCell(input.action() == MouseAction.MOTION && input.button().isEmpty());
+
+            byte[] encoded = mouseEncoder.encode(input);
+            if (encoded.length == 0) {
+                return false;
             }
 
-    public boolean floating() {
-        return floating;
+            if (session != null) {
+                session.send(encoded);
+            }
+            return true;
+        }
     }
 
-    public void setFloating(boolean floating) {
-        this.floating = floating;
+    public void scrollViewport(long rows) {
+        synchronized (terminal) {
+            terminal.scrollViewport(ScrollViewport.delta(rows));
+            refresh();
+        }
     }
 
+    private void scrollViewportToBottom() {
+        synchronized (terminal) {
+            terminal.scrollViewport(ScrollViewport.bottom());
+            refresh();
+        }
+    }
+
+    /**
+     * Incremental snapshot: cells are marshalled only for rows that changed since the last
+     * frame (global dirty == PARTIAL), reused across calls for the same content version.
+     * Snapshotting is deferred here rather than done in refresh(), so a burst of writes
+     * between two frames collapses into a single snapshot.
+     */
+    @Override
+    public RenderStateSnapshot snapshot() {
+        return takeSnapshot(false);
+    }
+
+    /**
+     * Full snapshot with every row's cells populated. Used where the whole pane is redrawn
+     * regardless of dirty state (the kitty-graphics path).
+     */
+    @Override
+    public RenderStateSnapshot snapshotFull() {
+        return takeSnapshot(true);
+    }
+
+    private RenderStateSnapshot takeSnapshot(boolean full) {
+        synchronized (terminal) {
+            long version = contentVersion.get();
+            if (full) {
+                renderState.update(terminal);
+                cachedSnapshot = renderState.snapshot();
+                renderState.resetDirty();
+                snapshotVersion = version;
+            } else if (snapshotVersion != version) {
+                renderState.update(terminal);
+                cachedSnapshot = renderState.snapshotIncremental();
+                renderState.resetDirty();
+                snapshotVersion = version;
+            }
+            return cachedSnapshot;
+        }
+    }
+
+    public String scrollbackText() {
+        synchronized (terminal) {
+            return terminal.text();
+        }
+    }
+
+    /** Best-effort current working directory of this pane's shell, or {@code null} if unknown. */
+    public String currentWorkingDirectory() {
+        ShellSession current = session;
+        return current != null ? current.currentWorkingDirectory() : null;
+    }
+
+    /** This pane's own content revision, bumped on every change (see {@link #refresh()}). */
+    public long contentVersion() {
+        return contentVersion.get();
+    }
+
+    @Override
+    public boolean kittyEnabled() {
+        return kittyEnabled;
+    }
+
+    @Override
+    public Optional<KittyGraphics> kittyGraphics() {
+        synchronized (terminal) {
+            return terminal.kittyGraphics();
+        }
+    }
+
+    @Override
     public double x() {
         return x;
     }
 
+    @Override
     public double y() {
         return y;
     }
 
+    @Override
     public double width() {
         return width;
     }
 
+    @Override
     public double height() {
         return height;
     }
@@ -85,16 +317,103 @@ public final class TerminalPane implements AutoCloseable {
         this.height = height;
     }
 
+    /** Set the clip region applied on the next paints (see {@link RenderTarget#clip()}). */
+    public void setClip(Shape clip) {
+        this.clip = clip;
+    }
+
+    @Override
+    public Shape clip() {
+        return clip;
+    }
+
+    /** Recompute the ghostty grid from the current bounds and the shared cell metrics. */
+    public void fitToBounds() {
+        int columns = metrics.columnsFor(width);
+        int rows = metrics.rowsFor(height);
+        resize(columns, rows, (int) Math.round(metrics.cellWidth()), (int) Math.round(metrics.lineHeight()));
+    }
+
+    private void resize(int columns, int rows, int pixelWidth, int pixelHeight) {
+        if (columns <= 0 || rows <= 0 || pixelWidth <= 0 || pixelHeight <= 0) {
+            return;
+        }
+        if (this.columns == columns && this.rows == rows && this.pixelWidth == pixelWidth && this.pixelHeight == pixelHeight) {
+            return;
+        }
+
+        synchronized (terminal) {
+            terminal.resize(columns, rows, pixelWidth, pixelHeight);
+            if (session != null) {
+                session.resize(columns, rows);
+            }
+            this.columns = columns;
+            this.rows = rows;
+            this.pixelWidth = pixelWidth;
+            this.pixelHeight = pixelHeight;
+            refresh();
+        }
+    }
+
     private void refresh() {
-        snapshotText.set(String.valueOf(terminal.snapshot()));
+        // Mark this pane's content dirty (the snapshot is computed lazily in the paint path,
+        // so a burst of writes collapses into one snapshot per frame) and tell the owning tab
+        // one of its panes changed.
+        contentVersion.incrementAndGet();
+        onContentChange.run();
+    }
+
+    /**
+     * Drop this pane's large, rebuildable render buffers because it is no longer being composited
+     * (e.g. it sits in a background tab or a hidden floating group). The pixel backbuffer and its GPU
+     * image are freed; the shell, ghostty terminal and shared glyph atlas are untouched, and the next
+     * {@link #paintFull} rebuilds the buffer. Safe to call repeatedly. See {@link TerminalRenderer#release}.
+     */
+    public void releaseRenderResources() {
+        renderer.release();
+    }
+
+    /** Paint the whole pane; see {@link TerminalRenderer#paintFull}. */
+    public long paintFull(GraphicsContext gc, boolean active) {
+        renderer.paintFull(gc, this, active);
+        return snapshotVersion;
+    }
+
+    /** Repaint what changed; see {@link TerminalRenderer#paintIncremental}. */
+    public long paintIncremental(GraphicsContext gc, boolean active) {
+        renderer.paintIncremental(gc, this, active);
+        return snapshotVersion;
+    }
+
+    /**
+     * Kitty image placements from the most recent paint, in scene coordinates. The compositor
+     * renders these as overlay nodes clipped to this pane (see {@link KittyImageOverlay}).
+     */
+    public java.util.List<KittyImageNode> kittyImages() {
+        return renderer.kittyImages();
     }
 
     @Override
     public void close() {
         if (session != null) {
-            session.close();
+            session.closeDetached();
             session = null;
         }
+        mouseEncoder.close();
+        renderState.close();
         terminal.close();
     }
+
+    /**
+     * Signals and reaps just the shell process, leaving the render/native state untouched. Unlike
+     * {@link #close()} this is safe to call off the FX thread — notably from a JVM shutdown hook,
+     * which runs concurrently with the live render loop — because it only touches the pty (a child
+     * process and fd), not ghostty's terminal handles. Idempotent; the OS reclaims the rest on exit.
+     */
+    public void terminateSession() {
+        ShellSession current = session;
+        if (current != null) {
+            current.close();
+        }
+    }
 }

src/main/java/com/gregor/jprototerm/TerminalRenderer.java

@@ -0,0 +1,70 @@
+package com.gregor.jprototerm;
+
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.shape.ClosePath;
+import javafx.scene.shape.LineTo;
+import javafx.scene.shape.MoveTo;
+import javafx.scene.shape.Path;
+import javafx.scene.shape.PathElement;
+import javafx.scene.shape.Shape;
+
+/**
+ * Draws a {@link RenderTarget} onto a JavaFX canvas. The {@link Compositor} owns positioning
+ * and z-order; a renderer only fills the target's rect, clipped to the target's {@link
+ * RenderTarget#clip() clip region} so a repaint can never bleed over a pane on top.
+ * Implementations can change the look entirely — {@link GhosttyTerminalRenderer} is the real
+ * terminal renderer; a debug renderer could outline pane bounds instead.
+ *
+ * <p>A renderer may hold per-target state (e.g. a decoded-image cache), so an instance belongs
+ * to a single {@link TerminalPane}.
+ */
+abstract class TerminalRenderer {
+    /** Paint the whole target into its rect, clipped to its clip region. */
+    abstract void paintFull(GraphicsContext gc, RenderTarget target, boolean active);
+
+    /** Repaint only what changed since the last frame, clipped to the target's clip region. */
+    abstract void paintIncremental(GraphicsContext gc, RenderTarget target, boolean active);
+
+    /**
+     * The kitty image placements produced by the most recent paint, for the compositor to render
+     * as overlay nodes above the canvas. Empty unless the last paint found visible images.
+     */
+    java.util.List<KittyImageNode> kittyImages() {
+        return java.util.List.of();
+    }
+
+    /**
+     * Release any large, rebuildable render buffers (e.g. a pane's pixel backbuffer) because the
+     * target is no longer being composited. A no-op by default; the next paint must rebuild whatever
+     * was dropped. Called off the paint path, so it must not assume a frame is in progress.
+     */
+    void release() {
+    }
+
+    /**
+     * Clip to {@code region} if given (the pane's rect minus the panes covering it, computed by
+     * {@code Shape.subtract} at layout), otherwise to the plain rect. The region is a rectilinear
+     * path, so it replays onto the canvas as move/line/close segments.
+     */
+    protected static void clip(GraphicsContext gc, double x, double y, double width, double height, Shape region) {
+        gc.beginPath();
+        if (region == null) {
+            gc.rect(x, y, width, height);
+        } else {
+            var elements = ((Path) region).getElements();
+            if (elements.isEmpty()) {
+                gc.rect(x, y, 0.0, 0.0); // fully covered: clip to nothing
+            }
+            for (PathElement element : elements) {
+                if (element instanceof MoveTo moveTo) {
+                    gc.moveTo(moveTo.getX(), moveTo.getY());
+                } else if (element instanceof LineTo lineTo) {
+                    gc.lineTo(lineTo.getX(), lineTo.getY());
+                } else if (element instanceof ClosePath) {
+                    gc.closePath();
+                }
+            }
+        }
+        gc.clip();
+    }
+}

src/main/java/com/gregor/jprototerm/TerminalWindow.java

@@ -0,0 +1,311 @@
+package com.gregor.jprototerm;
+
+import javafx.animation.AnimationTimer;
+import javafx.geometry.Rectangle2D;
+import javafx.scene.Scene;
+import javafx.scene.control.ButtonType;
+import javafx.scene.control.ComboBox;
+import javafx.scene.control.Dialog;
+import javafx.scene.control.Label;
+import javafx.scene.control.Spinner;
+import javafx.scene.control.SpinnerValueFactory;
+import javafx.scene.input.Clipboard;
+import javafx.scene.input.KeyEvent;
+import javafx.scene.layout.GridPane;
+import javafx.scene.layout.StackPane;
+import javafx.scene.text.Font;
+import javafx.stage.Screen;
+import javafx.stage.Stage;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * One top-level terminal window: its own {@link Stage}, {@link Compositor}, config/metrics, render
+ * loop and input handling. Many of these live in a single JVM under a {@link WindowManager}; closing
+ * one tears down only that window (its shells, its Stage) and leaves the rest — and, in daemon mode,
+ * the JVM — running. Built on the FX thread.
+ */
+final class TerminalWindow {
+    private final WindowManager manager;
+    private final TerminalMetrics metrics;
+    private final Compositor compositor;
+    private final Stage stage;
+    private final AnimationTimer renderLoop;
+    // Key-bound actions by their config keybinding name, checked in this order on each key press
+    // (the keys must match AppConfig's keybinding keys).
+    private final Map<String, Runnable> keyActions = new LinkedHashMap<>();
+    private AppConfig config;
+    private boolean closed;
+
+    TerminalWindow(WindowManager manager, String workingDirectory) {
+        this.manager = manager;
+        // Each window loads config independently, so edits (and per-window font changes) apply to
+        // newly opened windows without disturbing existing ones.
+        config = AppConfig.load();
+        StartupTiming.mark("config loaded");
+        metrics = new TerminalMetrics(config.fontFamily(), config.fontSize());
+        StartupTiming.mark("fonts loaded");
+        compositor = new Compositor(config, metrics, workingDirectory);
+        StartupTiming.mark("compositor ready");
+
+        // The last pane closing closes this window (not the JVM); see teardown().
+        compositor.setOnEmpty(this::teardown);
+
+        keyActions.put("navigate_left", () -> compositor.navigate(Direction.LEFT));
+        keyActions.put("navigate_down", () -> compositor.navigate(Direction.DOWN));
+        keyActions.put("navigate_up", () -> compositor.navigate(Direction.UP));
+        keyActions.put("navigate_right", () -> compositor.navigate(Direction.RIGHT));
+        keyActions.put("toggle_floating", compositor::toggleFloating);
+        keyActions.put("new_pane", compositor::createPane);
+        keyActions.put("next_floating", compositor::nextFloatingPane);
+        keyActions.put("promote_floating", compositor::toggleActiveFloating);
+        // Closing the last pane closes this window, via the compositor's onEmpty hook.
+        keyActions.put("close_pane", compositor::closeActivePane);
+        keyActions.put("new_tab", compositor::newTab);
+        keyActions.put("previous_tab", compositor::previousTab);
+        keyActions.put("next_tab", compositor::nextTab);
+        keyActions.put("open_font_selector", this::openFontSelector);
+        keyActions.put("open_scrollback", this::openScrollbackInEditor);
+        keyActions.put("create_worktree", this::createWorktreeInEditor);
+        keyActions.put("paste", this::pasteFromClipboard);
+
+        StackPane root = new StackPane(compositor.canvas(), compositor.imageOverlay());
+        compositor.canvas().widthProperty().bind(root.widthProperty());
+        compositor.canvas().heightProperty().bind(root.heightProperty());
+
+        Scene scene = new Scene(root, config.windowWidth(), config.windowHeight());
+        scene.addEventFilter(KeyEvent.KEY_PRESSED, this::handlePressed);
+        scene.addEventFilter(KeyEvent.KEY_TYPED, this::handleTyped);
+
+        renderLoop = new AnimationTimer() {
+            @Override
+            public void handle(long now) {
+                compositor.render();
+                StartupTiming.firstFrame();
+            }
+        };
+        renderLoop.start();
+
+        stage = new Stage();
+        stage.setTitle("jprototerm");
+        stage.setScene(scene);
+        // The X11 WM close button: tear this window down explicitly. With implicit exit disabled
+        // (see WindowManager) nothing else would reap the shells or drop the window otherwise.
+        stage.setOnCloseRequest(event -> teardown());
+        centreOnActiveScreen(stage, config.windowWidth(), config.windowHeight());
+        stage.show();
+        StartupTiming.mark("stage shown");
+        // Ask the window manager to raise and focus the new window so the user can type right
+        // away; the canvas requestFocus() below only routes events within the scene.
+        stage.toFront();
+        stage.requestFocus();
+        compositor.canvas().requestFocus();
+    }
+
+    /**
+     * Fully tears this window down (FX thread, idempotent): stops rendering, closes the compositor —
+     * which signals pane shells via the configured {@code close_signal} — disposes the Stage, and
+     * notifies the manager so it can drop the window (and, in standalone mode, exit the JVM). Both
+     * the WM close button and the last-pane-closed hook route through here.
+     */
+    void teardown() {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        renderLoop.stop();
+        compositor.close();
+        stage.close();
+        manager.onWindowClosed(this);
+    }
+
+    /** Signals and reaps this window's shell processes without touching render state (off-FX safe). */
+    void terminateSessions() {
+        compositor.terminateSessions();
+    }
+
+    private void handlePressed(KeyEvent event) {
+        for (Map.Entry<String, Runnable> action : keyActions.entrySet()) {
+            if (config.keybindings().get(action.getKey()).matches(event)) {
+                action.getValue().run();
+                event.consume();
+                return;
+            }
+        }
+        String encoded = KeyEncoder.encode(event);
+        if (encoded != null) {
+            sendToActivePane(encoded, event);
+        }
+    }
+
+    private void handleTyped(KeyEvent event) {
+        if (event.isAltDown() || event.isControlDown() || event.isMetaDown()) {
+            return;
+        }
+
+        String text = event.getCharacter();
+        if (text != null && !text.isEmpty() && text.charAt(0) >= 0x20 && text.charAt(0) != 0x7f) {
+            sendToActivePane(text, event);
+        }
+    }
+
+    // Key handlers run on every keystroke, including any that race the window's teardown, so
+    // tolerate the no-pane-left state instead of assuming one exists.
+    private void sendToActivePane(String text, KeyEvent event) {
+        TerminalPane active = compositor.activePane();
+        if (active != null) {
+            active.send(text);
+            event.consume();
+        }
+    }
+
+    private void pasteFromClipboard() {
+        TerminalPane active = compositor.activePane();
+        Clipboard clipboard = Clipboard.getSystemClipboard();
+        if (active != null && clipboard.hasString()) {
+            active.paste(clipboard.getString());
+        }
+    }
+
+    private void openFontSelector() {
+        Dialog<ButtonType> dialog = new Dialog<>();
+        dialog.setTitle("Font");
+        dialog.getDialogPane().getButtonTypes().addAll(ButtonType.OK, ButtonType.CANCEL);
+
+        ComboBox<String> family = new ComboBox<>();
+        family.getItems().setAll(Font.getFamilies());
+        family.setEditable(true);
+        family.setMaxWidth(Double.MAX_VALUE);
+        family.setValue(config.fontFamily());
+
+        Spinner<Double> size = new Spinner<>();
+        size.setEditable(true);
+        size.setValueFactory(new SpinnerValueFactory.DoubleSpinnerValueFactory(6.0, 48.0, config.fontSize(), 0.5));
+
+        GridPane content = new GridPane();
+        content.setHgap(10.0);
+        content.setVgap(10.0);
+        content.add(new Label("Family"), 0, 0);
+        content.add(family, 1, 0);
+        content.add(new Label("Size"), 0, 1);
+        content.add(size, 1, 1);
+        dialog.getDialogPane().setContent(content);
+
+        dialog.showAndWait()
+                .filter(button -> button == ButtonType.OK)
+                .ifPresent(ignored -> {
+                    String selectedFamily = family.getEditor().getText();
+                    if (selectedFamily == null || selectedFamily.isBlank()) {
+                        selectedFamily = family.getValue();
+                    }
+                    if (selectedFamily == null || selectedFamily.isBlank()) {
+                        return;
+                    }
+
+                    double selectedSize = size.getValue();
+                    config = config.withFont(selectedFamily.trim(), selectedSize);
+                    config.save();
+                    compositor.setFont(config.fontFamily(), config.fontSize());
+                    compositor.canvas().requestFocus();
+                });
+    }
+
+    private void openScrollbackInEditor() {
+        // Capture the active pane's scrollback before opening the floating pane, since that
+        // makes the new pane active.
+        TerminalPane active = compositor.activePane();
+        if (active == null) {
+            return;
+        }
+        try {
+            Path file = Files.createTempFile("jprototerm-scrollback-", ".txt");
+            Files.writeString(file, active.scrollbackText());
+
+            // Run the editor as the floating pane's process (via /bin/sh -c) rather than typing the
+            // command into an interactive shell. The command runs deterministically from the start
+            // — no shell startup/rc race — and the pane auto-closes when the editor exits. The
+            // trailing rm removes the file (which holds terminal contents) when the editor exits;
+            // deleteOnExit would leak files for the JVM's whole lifetime in daemon mode.
+            compositor.openFloatingPane(editorCommand(file) + "; rm -f " + shellQuote(file.toString()));
+        } catch (IOException ex) {
+            System.err.println("Could not open scrollback in editor: " + ex.getMessage());
+        }
+    }
+
+    private void createWorktreeInEditor() {
+        // The floating pane command inherits the active pane's cwd at creation time, so the git
+        // worktree command runs from the pane that was focused before this shortcut opened.
+        TerminalPane active = compositor.activePane();
+        if (active == null) {
+            return;
+        }
+        try {
+            Path file = Files.createTempFile("jprototerm-worktree-", ".txt");
+            Files.writeString(file, "");
+
+            compositor.openFloatingPane(worktreeEditorCommand(file));
+        } catch (IOException ex) {
+            System.err.println("Could not create worktree from editor input: " + ex.getMessage());
+        }
+    }
+
+    private String editorCommand(Path file) {
+        String quotedFile = shellQuote(file.toString());
+        String command = config.scrollbackEditorCommand();
+        if (command == null || command.isBlank()) {
+            command = "vi {file}";
+        }
+        if (command.contains("{file}")) {
+            return command.replace("{file}", quotedFile);
+        }
+        return command + " " + quotedFile;
+    }
+
+    private String worktreeEditorCommand(Path file) {
+        String quotedFile = shellQuote(file.toString());
+        String relativePath = config.worktreeRelativePath();
+        if (relativePath == null || relativePath.isBlank()) {
+            relativePath = "./.worktrees";
+        }
+
+        return editorCommand(file)
+                + "; editor_status=$?"
+                + "; name=$(cat " + quotedFile + ")"
+                + "; if [ \"$editor_status\" -eq 0 ] && [ -n \"$name\" ]; then"
+                + " git worktree add " + shellQuote(relativePath) + "/\"$name\""
+                + "; git_status=$?"
+                + "; else git_status=$editor_status"
+                + "; fi"
+                + "; rm -f " + quotedFile
+                + "; exit \"$git_status\"";
+    }
+
+    private static String shellQuote(String value) {
+        return "'" + value.replace("'", "'\"'\"'") + "'";
+    }
+
+    // Centre the stage within the screen the mouse pointer is on (the best proxy for the
+    // "active" monitor on X11, which exposes no focused-monitor concept to JavaFX).
+    private static void centreOnActiveScreen(Stage stage, double width, double height) {
+        Rectangle2D bounds = activeScreen().getVisualBounds();
+        stage.setX(bounds.getMinX() + ((bounds.getWidth() - width) / 2.0));
+        stage.setY(bounds.getMinY() + ((bounds.getHeight() - height) / 2.0));
+    }
+
+    private static Screen activeScreen() {
+        int[] at = X11Pointer.query();
+        if (at != null) {
+            // libX11 and JavaFX share a coordinate space on the X11 virtual screen.
+            List<Screen> screens = Screen.getScreensForRectangle(at[0], at[1], 1.0, 1.0);
+            if (!screens.isEmpty()) {
+                return screens.get(0);
+            }
+        }
+        return Screen.getPrimary();
+    }
+}

src/main/java/com/gregor/jprototerm/TerminalWorkspace.java

@@ -1,108 +0,0 @@
-package com.gregor.jprototerm;
-
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.List;
-
-public final class TerminalWorkspace implements AutoCloseable {
-    private final AppConfig config;
-    private final List<TerminalPane> panes = new ArrayList<>();
-    private int activeIndex;
-
-    public TerminalWorkspace(AppConfig config) {
-        this.config = config;
-        panes.add(openPane(false));
-    }
-
-    public TerminalPane activePane() {
-        return panes.get(activeIndex);
-    }
-
-    public List<TerminalPane> panes() {
-        return List.copyOf(panes);
-    }
-
-    public boolean isActive(TerminalPane pane) {
-        return activePane() == pane;
-    }
-
-    public void layout(double width, double height) {
-        List<TerminalPane> tiled = panes.stream().filter(pane -> !pane.floating()).toList();
-        int tileCount = Math.max(1, tiled.size());
-        double tileWidth = width / tileCount;
-        for (int i = 0; i < tiled.size(); i++) {
-            tiled.get(i).bounds(i * tileWidth, 0, tileWidth, height);
-        }
-
-        for (TerminalPane pane : panes) {
-            if (pane.floating()) {
-                double floatingWidth = Math.max(420, width * 0.58);
-                double floatingHeight = Math.max(260, height * 0.58);
-                pane.bounds(
-                        (width - floatingWidth) / 2.0,
-                        (height - floatingHeight) / 2.0,
-                        floatingWidth,
-                        floatingHeight
-                );
-            }
-        }
-    }
-
-    public void navigate(Direction direction) {
-        TerminalPane current = activePane();
-        panes.stream()
-                .filter(pane -> pane != current)
-                .filter(pane -> directionFilter(direction, current, pane))
-                .min(Comparator.comparingDouble(pane -> distance(current, pane)))
-                .ifPresent(pane -> activeIndex = panes.indexOf(pane));
-    }
-
-    public void toggleFloating() {
-        TerminalPane active = activePane();
-        if (active.floating()) {
-            panes.remove(activeIndex);
-            active.close();
-            activeIndex = Math.max(0, activeIndex - 1);
-            return;
-        }
-
-        TerminalPane pane = openPane(true);
-        panes.add(pane);
-        activeIndex = panes.size() - 1;
-    }
-
-    private TerminalPane openPane(boolean floating) {
-        TerminalPane pane = TerminalPane.create(config.columns(), config.rows(), config.kittyGraphics());
-        pane.setFloating(floating);
-        pane.attach(ShellSession.start(config.shell(), pane, pane.graphicsRegistry()));
-        return pane;
-    }
-
-    private static boolean directionFilter(Direction direction, TerminalPane current, TerminalPane candidate) {
-        double currentCenterX = current.x() + current.width() / 2.0;
-        double currentCenterY = current.y() + current.height() / 2.0;
-        double candidateCenterX = candidate.x() + candidate.width() / 2.0;
-        double candidateCenterY = candidate.y() + candidate.height() / 2.0;
-
-        return switch (direction) {
-            case LEFT -> candidateCenterX < currentCenterX;
-            case DOWN -> candidateCenterY > currentCenterY;
-            case UP -> candidateCenterY < currentCenterY;
-            case RIGHT -> candidateCenterX > currentCenterX;
-        };
-    }
-
-    private static double distance(TerminalPane current, TerminalPane candidate) {
-        double dx = (current.x() + current.width() / 2.0) - (candidate.x() + candidate.width() / 2.0);
-        double dy = (current.y() + current.height() / 2.0) - (candidate.y() + candidate.height() / 2.0);
-        return Math.sqrt(dx * dx + dy * dy);
-    }
-
-    @Override
-    public void close() {
-        for (TerminalPane pane : panes) {
-            pane.close();
-        }
-        panes.clear();
-    }
-}

src/main/java/com/gregor/jprototerm/WindowManager.java

@@ -0,0 +1,69 @@
+package com.gregor.jprototerm;
+
+import javafx.application.Platform;
+
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArraySet;
+
+/**
+ * Owns the JavaFX toolkit lifecycle and the set of live {@link TerminalWindow}s for one JVM. A
+ * single JVM hosts every window, so the expensive toolkit/GL init is paid once; opening another
+ * window is then just a new {@link javafx.stage.Stage}.
+ *
+ * <p>Two modes differ only in the empty policy: in {@link Mode#STANDALONE} (today's behavior, used
+ * as the fallback when no daemon is reachable) the JVM exits once the last window closes; in
+ * {@link Mode#DAEMON} the toolkit stays alive with zero windows, waiting for the next client
+ * request. {@link Platform#setImplicitExit(boolean) implicit exit} is disabled in both so the
+ * toolkit never tears itself down behind our back — every exit is an explicit decision here.
+ */
+public final class WindowManager {
+    public enum Mode {
+        STANDALONE,
+        DAEMON
+    }
+
+    private final Mode mode;
+    // Mutated on the FX thread (register/deregister), iterated from the shutdown-hook thread.
+    private final Set<TerminalWindow> windows = new CopyOnWriteArraySet<>();
+
+    private WindowManager(Mode mode) {
+        this.mode = mode;
+    }
+
+    /**
+     * Brings up the JavaFX toolkit (once per JVM) and returns a manager in {@code mode}. Registers a
+     * shutdown hook that reaps every window's shell processes, so child shells are terminated rather
+     * than orphaned if the JVM is killed (SIGTERM/SIGINT/SIGHUP) — see
+     * {@link Compositor#terminateSessions()}.
+     */
+    public static WindowManager start(Mode mode) {
+        WindowManager manager = new WindowManager(mode);
+        Platform.setImplicitExit(false);
+        Platform.startup(() -> StartupTiming.mark("toolkit ready"));
+        Runtime.getRuntime().addShutdownHook(new Thread(manager::terminateAllSessions, "shell-cleanup"));
+        return manager;
+    }
+
+    /** Opens a new window (on the FX thread) whose first pane starts in {@code workingDirectory}. */
+    public void openWindow(String workingDirectory) {
+        Platform.runLater(() -> windows.add(new TerminalWindow(this, workingDirectory)));
+    }
+
+    /**
+     * Called by a window when it has finished tearing down (FX thread). Drops it from the registry
+     * and, in standalone mode, exits the JVM once none remain.
+     */
+    void onWindowClosed(TerminalWindow window) {
+        windows.remove(window);
+        if (mode == Mode.STANDALONE && windows.isEmpty()) {
+            Platform.exit();
+        }
+    }
+
+    /** Signals and reaps every live window's shell processes. Safe to call off the FX thread. */
+    void terminateAllSessions() {
+        for (TerminalWindow window : windows) {
+            window.terminateSessions();
+        }
+    }
+}

src/main/java/com/gregor/jprototerm/X11Pointer.java

@@ -0,0 +1,66 @@
+package com.gregor.jprototerm;
+
+import java.lang.foreign.Arena;
+import java.lang.foreign.FunctionDescriptor;
+import java.lang.foreign.Linker;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.SymbolLookup;
+import java.lang.invoke.MethodHandle;
+
+import static java.lang.foreign.ValueLayout.ADDRESS;
+import static java.lang.foreign.ValueLayout.JAVA_INT;
+import static java.lang.foreign.ValueLayout.JAVA_LONG;
+
+/**
+ * Reads the X11 pointer location directly via libX11 ({@code XQueryPointer}). Unlike AWT's
+ * {@code MouseInfo}, this never calls {@code XSetErrorHandler}, so it doesn't trip GDK's
+ * "XSetErrorHandler called with a GDK error trap pushed" warning when JavaFX's GTK backend is
+ * already up. Returns {@code null} when not on X11 or libX11 can't be loaded.
+ */
+final class X11Pointer {
+    private X11Pointer() {
+    }
+
+    /** {@code {x, y}} of the pointer in X root-window (virtual screen) space, or {@code null}. */
+    static int[] query() {
+        try (Arena arena = Arena.ofConfined()) {
+            Linker linker = Linker.nativeLinker();
+            SymbolLookup x11 = SymbolLookup.libraryLookup("libX11.so.6", arena);
+            MethodHandle openDisplay = linker.downcallHandle(x11.find("XOpenDisplay").orElseThrow(),
+                    FunctionDescriptor.of(ADDRESS, ADDRESS));
+            MethodHandle defaultRootWindow = linker.downcallHandle(x11.find("XDefaultRootWindow").orElseThrow(),
+                    FunctionDescriptor.of(JAVA_LONG, ADDRESS));
+            MethodHandle queryPointer = linker.downcallHandle(x11.find("XQueryPointer").orElseThrow(),
+                    FunctionDescriptor.of(JAVA_INT, ADDRESS, JAVA_LONG,
+                            ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS));
+            MethodHandle closeDisplay = linker.downcallHandle(x11.find("XCloseDisplay").orElseThrow(),
+                    FunctionDescriptor.of(JAVA_INT, ADDRESS));
+
+            MemorySegment display = (MemorySegment) openDisplay.invoke(MemorySegment.NULL);
+            if (display.address() == 0) {
+                return null;
+            }
+            try {
+                long root = (long) defaultRootWindow.invoke(display);
+                MemorySegment rootReturn = arena.allocate(JAVA_LONG);
+                MemorySegment childReturn = arena.allocate(JAVA_LONG);
+                MemorySegment rootX = arena.allocate(JAVA_INT);
+                MemorySegment rootY = arena.allocate(JAVA_INT);
+                MemorySegment winX = arena.allocate(JAVA_INT);
+                MemorySegment winY = arena.allocate(JAVA_INT);
+                MemorySegment mask = arena.allocate(JAVA_INT);
+                int onSameScreen = (int) queryPointer.invoke(display, root,
+                        rootReturn, childReturn, rootX, rootY, winX, winY, mask);
+                if (onSameScreen == 0) {
+                    return null;
+                }
+                return new int[] { rootX.get(JAVA_INT, 0), rootY.get(JAVA_INT, 0) };
+            } finally {
+                closeDisplay.invoke(display);
+            }
+        } catch (Throwable ignored) {
+            // Not X11, libX11 missing, or the call failed — caller falls back to the primary screen.
+            return null;
+        }
+    }
+}

src/main/resources/META-INF/native-image/com.gregor/jprototerm/reflect-config.json

@@ -1,37 +0,0 @@
-[
-  {
-    "name": "com.gregor.jprototerm.Main",
-    "allDeclaredConstructors": true,
-    "allPublicConstructors": true
-  },
-  {
-    "name": "com.sun.javafx.tk.quantum.QuantumToolkit",
-    "allDeclaredConstructors": true,
-    "allPublicConstructors": true
-  },
-  {
-    "name": "com.sun.glass.ui.gtk.GtkPlatformFactory",
-    "allDeclaredConstructors": true,
-    "allPublicConstructors": true
-  },
-  {
-    "name": "com.sun.glass.ui.gtk.GtkApplication",
-    "allDeclaredConstructors": true,
-    "allPublicConstructors": true
-  },
-  {
-    "name": "com.sun.prism.es2.ES2Pipeline",
-    "allDeclaredConstructors": true,
-    "allPublicConstructors": true
-  },
-  {
-    "name": "com.sun.prism.es2.X11GLFactory",
-    "allDeclaredConstructors": true,
-    "allPublicConstructors": true
-  },
-  {
-    "name": "com.sun.prism.sw.SWPipeline",
-    "allDeclaredConstructors": true,
-    "allPublicConstructors": true
-  }
-]

src/main/resources/META-INF/native-image/com.gregor/jprototerm/resource-config.json

@@ -1,6 +0,0 @@
-{
-  "resources": [
-    { "pattern": ".*\\.css$" },
-    { "pattern": ".*\\.toml$" }
-  ]
-}