Revert "fix glyph-overhang artifacts in partial row repaint"

This reverts commit 57103bb98b.

.codexsession

@@ -0,0 +1 @@
+019e6999-b7c8-7591-a8aa-ea51b89a7f7e

.gitignore

@@ -12,3 +12,5 @@ devenv.local.yaml
 .pre-commit-config.yaml
 build
 build
+.gradle
+bin

.gradle/buildOutputCleanup/cache.properties

@@ -1,2 +0,0 @@
-#Wed May 27 23:44:22 CEST 2026
-gradle.version=9.4.1

.ignore

@@ -0,0 +1,3 @@
+.gradle
+result
+bin

.settings/org.eclipse.buildship.core.prefs

@@ -1,7 +1,7 @@
-arguments=--init-script /home/anon/.eclipse/1927926929_linux_gtk_x86_64/configuration/org.eclipse.osgi/58/0/.cp/gradle/init/init.gradle
+arguments=--init-script /home/anon/Src/eclipse.jdt.ls/org.eclipse.jdt.ls.product/target/repository/configuration/org.eclipse.osgi/58/0/.cp/gradle/init/init.gradle
 auto.sync=false
 build.scans.enabled=false
-connection.gradle.distribution=GRADLE_DISTRIBUTION(VERSION(8.9))
+connection.gradle.distribution=GRADLE_DISTRIBUTION(LOCAL_INSTALLATION(/home/anon/.sdkman/candidates/gradle/current))
 connection.project.dir=
 eclipse.preferences.version=1
 gradle.user.home=

README.md

@@ -1,24 +1,64 @@
 # 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.
 
 ## Build
 
 ```sh
 nix build
+./result/bin/jprototerm
 ```
 
-The package build uses GluonFX through Gradle so JavaFX native-image metadata is generated by the toolchain that is designed for it. In a strict pure Nix sandbox, Gradle dependencies must be vendored first with `gradle2nix` or a checked-in Maven/Gradle cache.
+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 run
-gradle -PjlibghosttyMavenRepo="$JLIBGHOSTTY_MAVEN_REPO" -Pgluonfx.mainClassName=com.gregor.jprototerm.Main nativeExecutable
 ```
 
-The Gradle project is the source of truth for native JavaFX builds.
+The Gradle project is the source of truth for the JavaFX build.
 
 ## Config
 
@@ -53,25 +93,42 @@ height = 760
 [kitty_graphics]
 enabled = true
 
+[scrollback]
+editor_command = "vi {file}"
+
+[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_floating = "ALT+SHIFT+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"
 ```
 
 ## Defaults
 
 - `Alt+h/j/k/l`: navigate panes
+- `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+Shift+f`: create a new floating pane
+- `Alt+x`: close the active pane; closing a tab's last pane closes the tab, and closing the
-- `Alt+F12`: cycle floating panes
+  last pane of the last tab quits
-- `Alt+x`: close the active floating pane
+- `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`
 - 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

@@ -14,11 +14,10 @@ repositories {
 dependencies {
     implementation 'io.github.wasabithumb:jtoml:1.5.2'
     implementation 'dev.jlibghostty:jlibghostty:0.1.0-SNAPSHOT'
-    implementation 'org.jetbrains.pty4j:pty4j:0.13.11'
 }
 
 javafx {
-    version = '22'
+    version = '25'
     modules = [ 'javafx.controls', 'javafx.fxml' ]
 }
 

config.example.toml

@@ -13,13 +13,19 @@ height = 760
 [kitty_graphics]
 enabled = true
 
+[scrollback]
+editor_command = "vi {file}"
+
+[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_floating = "ALT+SHIFT+F"
+new_pane = "ALT+N"
-next_floating = "ALT+F12"
 close_pane = "ALT+X"
 open_font_selector = "ALT+T"
+open_scrollback = "ALT+S"

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

@@ -0,0 +1,226 @@
+{
+  "nodes": {
+    "flake-compat": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1761588595,
+        "narHash": "sha256-XKUZz9zewJNUj46b4AJdiRZJAvSZ0Dqj2BNfXvFlJC4=",
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "rev": "f387cd2afec9419c8ee37694406ca490c3f34ee5",
+        "type": "github"
+      },
+      "original": {
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "type": "github"
+      }
+    },
+    "ghostty": {
+      "inputs": {
+        "flake-compat": "flake-compat",
+        "home-manager": "home-manager",
+        "nixpkgs": [
+          "jlibghostty",
+          "nixpkgs"
+        ],
+        "systems": "systems",
+        "zig": "zig",
+        "zon2nix": "zon2nix"
+      },
+      "locked": {
+        "lastModified": 1779812402,
+        "narHash": "sha256-gozJEyJHbaAyrbzODKeWJhxpUrGK6m4DIPDogfjz2BU=",
+        "owner": "ghostty-org",
+        "repo": "ghostty",
+        "rev": "2e5ad917eb4e325a3dbb161c3f41208a8cd35e44",
+        "type": "github"
+      },
+      "original": {
+        "owner": "ghostty-org",
+        "repo": "ghostty",
+        "type": "github"
+      }
+    },
+    "home-manager": {
+      "inputs": {
+        "nixpkgs": [
+          "jlibghostty",
+          "ghostty",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1770586272,
+        "narHash": "sha256-Ucci8mu8QfxwzyfER2DQDbvW9t1BnTUJhBmY7ybralo=",
+        "owner": "nix-community",
+        "repo": "home-manager",
+        "rev": "b1f916ba052341edc1f80d4b2399f1092a4873ca",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-community",
+        "repo": "home-manager",
+        "type": "github"
+      }
+    },
+    "jlibghostty": {
+      "inputs": {
+        "ghostty": "ghostty",
+        "nixpkgs": "nixpkgs"
+      },
+      "locked": {
+        "lastModified": 1780256181,
+        "narHash": "sha256-/saXdnYMbAMfP7u6USSqtNkBIgqZhU+CPr3F8tUQhHU=",
+        "ref": "refs/heads/main",
+        "rev": "db5ee5d20daf8855de3a3b2fa9349eced70946f0",
+        "revCount": 21,
+        "type": "git",
+        "url": "https://gitea.gregorlohaus.com/gregor/jlibghostty.git"
+      },
+      "original": {
+        "type": "git",
+        "url": "https://gitea.gregorlohaus.com/gregor/jlibghostty.git"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1779560665,
+        "narHash": "sha256-tpyBcxPpcQb8ukyNF7DoCwfSY3VPsxHoYwj00Cayv5o=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "64c08a7ca051951c8eae34e3e3cb1e202fe36786",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1779560665,
+        "narHash": "sha256-tpyBcxPpcQb8ukyNF7DoCwfSY3VPsxHoYwj00Cayv5o=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "64c08a7ca051951c8eae34e3e3cb1e202fe36786",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "ghostty": [
+          "jlibghostty",
+          "ghostty"
+        ],
+        "jlibghostty": "jlibghostty",
+        "nixpkgs": "nixpkgs_2"
+      }
+    },
+    "systems": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    },
+    "zig": {
+      "inputs": {
+        "flake-compat": [
+          "jlibghostty",
+          "ghostty",
+          "flake-compat"
+        ],
+        "nixpkgs": [
+          "jlibghostty",
+          "ghostty",
+          "nixpkgs"
+        ],
+        "systems": [
+          "jlibghostty",
+          "ghostty",
+          "systems"
+        ]
+      },
+      "locked": {
+        "lastModified": 1776789209,
+        "narHash": "sha256-G6B7Q4TXn7MZ1mB+f9rymjsYF5PLWoSvmbxijb/99bw=",
+        "owner": "mitchellh",
+        "repo": "zig-overlay",
+        "rev": "14fe971844e841297ddd2ce9783d6892b467af39",
+        "type": "github"
+      },
+      "original": {
+        "owner": "mitchellh",
+        "repo": "zig-overlay",
+        "type": "github"
+      }
+    },
+    "zig_2": {
+      "inputs": {
+        "nixpkgs": [
+          "jlibghostty",
+          "ghostty",
+          "zon2nix",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1777234348,
+        "narHash": "sha256-fKw44a4qbUuI5eTG8k0gPbqMV5TOrjYF35PBzsYgd2U=",
+        "ref": "refs/heads/main",
+        "rev": "2c781c0609ecda600ab98f98cca417bbd981bd53",
+        "revCount": 1677,
+        "type": "git",
+        "url": "https://codeberg.org/jcollie/zig-overlay.git"
+      },
+      "original": {
+        "type": "git",
+        "url": "https://codeberg.org/jcollie/zig-overlay.git"
+      }
+    },
+    "zon2nix": {
+      "inputs": {
+        "nixpkgs": [
+          "jlibghostty",
+          "ghostty",
+          "nixpkgs"
+        ],
+        "zig": "zig_2"
+      },
+      "locked": {
+        "lastModified": 1777314365,
+        "narHash": "sha256-eLxQaD0wc96Neqkln8wHS0rNq/chPODifFkhwrwilEU=",
+        "owner": "jcollie",
+        "repo": "zon2nix",
+        "rev": "a5a1d412ad1ab6305511997bbc92b3a9dd6cb784",
+        "type": "github"
+      },
+      "original": {
+        "owner": "jcollie",
+        "ref": "main",
+        "repo": "zon2nix",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,150 @@
+{
+  description = "jprototerm";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+    jlibghostty.url = "git+https://gitea.gregorlohaus.com/gregor/jlibghostty.git";
+    ghostty.follows = "jlibghostty/ghostty";
+  };
+
+  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
+          pkgs = import nixpkgs { inherit system; };
+
+          jlib = jlibghostty.packages.${system}.jlibghostty;
+          ghosttyVt = ghostty.packages.${system}.libghostty-vt;
+
+          runtimeLibs = runtimeLibsFor pkgs ghosttyVt;
+
+          jprototerm = pkgs.stdenv.mkDerivation (finalAttrs: {
+            pname = "jprototerm";
+            version = "0.1.0";
+            src = ./.;
+
+            nativeBuildInputs = [
+              pkgs.jdk25
+              pkgs.gradle_9
+              pkgs.makeWrapper
+            ];
+
+            buildInputs = runtimeLibs;
+
+            mitmCache = pkgs.gradle_9.fetchDeps {
+              pkg = finalAttrs.finalPackage;
+              data = ./deps.json;
+              useBwrap = false;
+            };
+
+            # 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}"
+            ];
+
+            JAVA_HOME = "${pkgs.jdk25}";
+            JLIBGHOSTTY_MAVEN_REPO = "${jlib}/maven";
+
+            preBuild = ''
+              export HOME="$TMPDIR/home"
+              export GRADLE_OPTS="-Duser.home=$HOME ''${GRADLE_OPTS:-}"
+            '';
+
+            preGradleUpdate = ''
+              export HOME="$TMPDIR/home"
+            '';
+
+            installPhase = ''
+              runHook preInstall
+
+              mkdir -p "$out/share/jprototerm"
+              cp -a build/install/jprototerm/lib "$out/share/jprototerm/lib"
+
+              # 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
+
+              makeWrapper "${pkgs.jdk25}/bin/java" "$out/bin/jprototerm" \
+                --run 'export JPROTOTERM_HOST_LD_LIBRARY_PATH="''${LD_LIBRARY_PATH:-}"' \
+                --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
+
+              runHook postInstall
+            '';
+          });
+        in {
+          default = jprototerm;
+          gradleDepsUpdateScript = jprototerm.mitmCache.updateScript;
+        });
+
+      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 = [
+              pkgs.gradle_9
+              pkgs.jdk25
+              pkgs.jdt-language-server
+            ] ++ runtimeLibs;
+
+            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'

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

@@ -3,6 +3,7 @@ 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.primitive.TomlPrimitive;
 import io.github.wasabithumb.jtoml.value.table.TomlTable;
@@ -25,6 +26,8 @@ public record AppConfig(
         double windowWidth,
         double windowHeight,
         boolean kittyGraphics,
+        String scrollbackEditorCommand,
+        Map<String, String> envOverride,
         Map<String, KeyBinding> keybindings
 ) {
     private static final List<String> KEYBINDING_KEYS = List.of(
@@ -33,10 +36,13 @@ public record AppConfig(
             "navigate_up",
             "navigate_right",
             "toggle_floating",
-            "new_floating",
+            "new_pane",
-            "next_floating",
             "close_pane",
-            "open_font_selector"
+            "new_tab",
+            "previous_tab",
+            "next_tab",
+            "open_font_selector",
+            "open_scrollback"
     );
 
     public static AppConfig load() {
@@ -59,6 +65,8 @@ public record AppConfig(
                     doubleValue(document, "window.width", defaults.windowWidth),
                     doubleValue(document, "window.height", defaults.windowHeight),
                     booleanValue(document, "kitty_graphics.enabled", defaults.kittyGraphics),
+                    stringValue(document, "scrollback.editor_command", defaults.scrollbackEditorCommand),
+                    envOverride(document, defaults.envOverride),
                     keybindings(document, defaults)
             );
         } catch (TomlException ex) {
@@ -78,16 +86,21 @@ public record AppConfig(
                 1200.0,
                 760.0,
                 true,
-                Map.of(
+                defaultScrollbackEditorCommand(),
-                        "navigate_left", KeyBinding.parse("ALT+H"),
+                Map.of(),
-                        "navigate_down", KeyBinding.parse("ALT+J"),
+                Map.ofEntries(
-                        "navigate_up", KeyBinding.parse("ALT+K"),
+                        Map.entry("navigate_left", KeyBinding.parse("ALT+H")),
-                        "navigate_right", KeyBinding.parse("ALT+L"),
+                        Map.entry("navigate_down", KeyBinding.parse("ALT+J")),
-                        "toggle_floating", KeyBinding.parse("ALT+F"),
+                        Map.entry("navigate_up", KeyBinding.parse("ALT+K")),
-                        "new_floating", KeyBinding.parse("ALT+SHIFT+F"),
+                        Map.entry("navigate_right", KeyBinding.parse("ALT+L")),
-                        "next_floating", KeyBinding.parse("ALT+F12"),
+                        Map.entry("toggle_floating", KeyBinding.parse("ALT+F")),
-                        "close_pane", KeyBinding.parse("ALT+X"),
+                        Map.entry("new_pane", KeyBinding.parse("ALT+N")),
-                        "open_font_selector", KeyBinding.parse("ALT+T")
+                        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"))
                 )
         );
     }
@@ -103,6 +116,8 @@ public record AppConfig(
                 windowWidth,
                 windowHeight,
                 kittyGraphics,
+                scrollbackEditorCommand,
+                envOverride,
                 keybindings
         );
     }
@@ -123,6 +138,14 @@ public record AppConfig(
         return "/bin/bash";
     }
 
+    private static String defaultScrollbackEditorCommand() {
+        String editor = System.getenv("EDITOR");
+        if (editor == null || editor.isBlank()) {
+            editor = "vi";
+        }
+        return editor.trim() + " {file}";
+    }
+
     private static Map<String, KeyBinding> keybindings(TomlTable table, AppConfig defaults) {
         Map<String, KeyBinding> parsed = new LinkedHashMap<>();
         for (String key : KEYBINDING_KEYS) {
@@ -167,6 +190,13 @@ public record AppConfig(
         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("[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);
@@ -206,6 +236,31 @@ 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();

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

@@ -0,0 +1,442 @@
+package com.gregor.jprototerm;
+
+import dev.jlibghostty.KeyModifiers;
+import dev.jlibghostty.MouseButton;
+import dev.jlibghostty.MouseEncoderSize;
+import dev.jlibghostty.MouseInput;
+import javafx.geometry.Pos;
+import javafx.scene.Parent;
+import javafx.scene.control.Label;
+import javafx.scene.input.InputEvent;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.input.ScrollEvent;
+import javafx.scene.input.ScrollEvent.VerticalTextScrollUnits;
+import javafx.scene.layout.Background;
+import javafx.scene.layout.BackgroundFill;
+import javafx.scene.layout.CornerRadii;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.Pane;
+import javafx.scene.paint.Color;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Owns the window's tabs and exposes the terminal surface as a JavaFX scene graph. Each
+ * terminal pane is mounted as its own node, so JavaFX child order handles stacking and clipping
+ * between panes. The pane model still owns terminals, ptys, cell geometry, and snapshots; this
+ * class handles tab/pane lifecycle, layout, focus, mouse routing, and frame scheduling.
+ */
+public final class Compositor {
+    private static final Color GAP_BACKGROUND = Color.rgb(16, 16, 18);
+    private static final Color TAB_TEXT = Color.rgb(225, 229, 235);
+    private static final Color TAB_INACTIVE_TEXT = Color.rgb(128, 136, 148);
+    private static final Color TAB_ACTIVE_BACKGROUND = Color.rgb(45, 55, 72);
+    private static final Color TAB_INACTIVE_BACKGROUND = Color.rgb(22, 24, 28);
+    private static final double TAB_BAR_HEIGHT = 22.0;
+
+    private final Pane root = new Pane();
+    private final Pane paneLayer = new Pane();
+    private final HBox tabBar = new HBox(1.0);
+    private final AppConfig config;
+    private final TerminalMetrics metrics;
+    private final List<Tab> tabs = new ArrayList<>();
+    private final Map<TerminalPane, TerminalPaneNode> nodes = new HashMap<>();
+    private int currentTabIndex;
+    private boolean sceneDirty = true;
+    private double lastWidth = -1.0;
+    private double lastHeight = -1.0;
+    private long lastContentVersion = Long.MIN_VALUE;
+    private boolean mouseButtonPressed;
+    private MouseButton pressedButton = MouseButton.UNKNOWN;
+
+    public Compositor(AppConfig config, TerminalMetrics metrics) {
+        this.config = config;
+        this.metrics = metrics;
+        tabs.add(new Tab(config, metrics));
+
+        root.setFocusTraversable(true);
+        root.setBackground(new Background(new BackgroundFill(GAP_BACKGROUND, CornerRadii.EMPTY, null)));
+        root.getChildren().setAll(paneLayer, tabBar);
+        root.setOnMousePressed(event -> root.requestFocus());
+    }
+
+    public Parent node() {
+        return root;
+    }
+
+    public void requestFocus() {
+        root.requestFocus();
+    }
+
+    public void setFont(String family, double size) {
+        metrics.setFont(family, size);
+        nodes.values().forEach(TerminalPaneNode::discard);
+        markSceneDirty();
+    }
+
+    // ---- Tabs and panes -------------------------------------------------------------
+
+    public boolean isEmpty() {
+        return tabs.isEmpty();
+    }
+
+    public TerminalPane activePane() {
+        return currentTab().activePane();
+    }
+
+    public void navigate(Direction direction) {
+        if (!isEmpty() && currentTab().navigate(direction)) {
+            markSceneDirty();
+        }
+    }
+
+    public void toggleFloating() {
+        if (isEmpty()) {
+            return;
+        }
+        currentTab().toggleFloating();
+        markSceneDirty();
+    }
+
+    public void createPane() {
+        if (isEmpty()) {
+            return;
+        }
+        currentTab().createPane();
+        markSceneDirty();
+    }
+
+    public void closeActivePane() {
+        if (isEmpty()) {
+            return;
+        }
+        currentTab().closeActivePane();
+        if (currentTab().isEmpty()) {
+            tabs.remove(currentTabIndex);
+            if (currentTabIndex >= tabs.size()) {
+                currentTabIndex = Math.max(0, tabs.size() - 1);
+            }
+        }
+        markSceneDirty();
+    }
+
+    public void newTab() {
+        tabs.add(new Tab(config, metrics));
+        currentTabIndex = tabs.size() - 1;
+        markSceneDirty();
+    }
+
+    public void nextTab() {
+        if (tabs.size() > 1) {
+            currentTabIndex = (currentTabIndex + 1) % tabs.size();
+            markSceneDirty();
+        }
+    }
+
+    public void previousTab() {
+        if (tabs.size() > 1) {
+            currentTabIndex = (currentTabIndex - 1 + tabs.size()) % tabs.size();
+            markSceneDirty();
+        }
+    }
+
+    public void close() {
+        for (Tab tab : tabs) {
+            tab.close();
+        }
+        tabs.clear();
+        nodes.clear();
+        paneLayer.getChildren().clear();
+    }
+
+    private Tab currentTab() {
+        return tabs.get(currentTabIndex);
+    }
+
+    private List<TerminalPane> currentPanes() {
+        return tabs.isEmpty() ? List.of() : currentTab().panes();
+    }
+
+    private List<TerminalPane> allOpenPanes() {
+        List<TerminalPane> panes = new ArrayList<>();
+        for (Tab tab : tabs) {
+            panes.addAll(tab.allPanes());
+        }
+        return panes;
+    }
+
+    private boolean isActive(TerminalPane pane) {
+        return !tabs.isEmpty() && currentTab().isActive(pane);
+    }
+
+    private void focus(TerminalPane pane) {
+        if (!tabs.isEmpty() && currentTab().focus(pane)) {
+            markSceneDirty();
+        }
+    }
+
+    // ---- Rendering ------------------------------------------------------------------
+
+    public void render() {
+        double width = root.getWidth();
+        double height = root.getHeight();
+        long contentVersion = tabs.isEmpty() ? 0 : currentTab().contentVersion();
+        boolean geometryChanged = width != lastWidth || height != lastHeight;
+        boolean contentChanged = contentVersion != lastContentVersion;
+        boolean syncScene = sceneDirty || geometryChanged;
+
+        if (!syncScene && !contentChanged) {
+            return;
+        }
+
+        lastWidth = width;
+        lastHeight = height;
+        lastContentVersion = contentVersion;
+        sceneDirty = false;
+        if (syncScene) {
+            syncSceneGraph(width, height);
+        }
+        renderVisiblePanes();
+    }
+
+    private void markSceneDirty() {
+        sceneDirty = true;
+    }
+
+    private void syncSceneGraph(double width, double height) {
+        double topInset = tabs.size() > 1 ? TAB_BAR_HEIGHT : 0.0;
+
+        paneLayer.resizeRelocate(0.0, 0.0, width, height);
+        updateTabBar(width, topInset);
+
+        if (!tabs.isEmpty()) {
+            currentTab().layout(width, height, topInset);
+        }
+
+        List<TerminalPane> panes = currentPanes();
+        retainNodes(allOpenPanes());
+        List<TerminalPaneNode> orderedNodes = new ArrayList<>(panes.size());
+        for (TerminalPane pane : panes) {
+            pane.fitToBounds();
+            TerminalPaneNode node = nodeFor(pane);
+            node.resizeRelocate(Math.round(pane.x()), Math.round(pane.y()), pane.width(), pane.height());
+            orderedNodes.add(node);
+        }
+        paneLayer.getChildren().setAll(orderedNodes);
+    }
+
+    private void renderVisiblePanes() {
+        for (TerminalPane pane : currentPanes()) {
+            TerminalPaneNode node = nodes.get(pane);
+            if (node != null) {
+                node.renderIncremental(isActive(pane));
+            }
+        }
+    }
+
+    private TerminalPaneNode nodeFor(TerminalPane pane) {
+        return nodes.computeIfAbsent(pane, this::createNode);
+    }
+
+    private TerminalPaneNode createNode(TerminalPane pane) {
+        TerminalPaneNode node = new TerminalPaneNode(pane, metrics);
+        node.setOnMousePressed(event -> handleMousePressed(pane, event));
+        node.setOnMouseReleased(event -> handleMouseReleased(pane, event));
+        node.setOnMouseDragged(event -> handleMouseDragged(pane, event));
+        node.setOnMouseMoved(event -> handleMouseMoved(pane, event));
+        node.setOnScroll(event -> handleScroll(pane, event));
+        return node;
+    }
+
+    private void retainNodes(List<TerminalPane> openPanes) {
+        Set<TerminalPane> open = new HashSet<>(openPanes);
+        nodes.keySet().removeIf(pane -> !open.contains(pane));
+    }
+
+    private void updateTabBar(double width, double barHeight) {
+        tabBar.setVisible(barHeight > 0.0);
+        tabBar.setManaged(false);
+        tabBar.resizeRelocate(0.0, 0.0, width, barHeight);
+        tabBar.getChildren().clear();
+        if (barHeight <= 0.0) {
+            return;
+        }
+
+        double segmentWidth = width / tabs.size();
+        for (int i = 0; i < tabs.size(); i++) {
+            Label label = new Label(Integer.toString(i + 1));
+            boolean current = i == currentTabIndex;
+            label.setAlignment(Pos.CENTER);
+            label.setTextFill(current ? TAB_TEXT : TAB_INACTIVE_TEXT);
+            label.setBackground(new Background(new BackgroundFill(
+                    current ? TAB_ACTIVE_BACKGROUND : TAB_INACTIVE_BACKGROUND,
+                    CornerRadii.EMPTY,
+                    null)));
+            label.setFont(javafx.scene.text.Font.font(metrics.fontFamily(), Math.max(9.0, Math.min(13.0, barHeight * 0.62))));
+            label.setMinSize(0.0, barHeight);
+            label.setPrefSize(Math.max(0.0, segmentWidth - 1.0), barHeight);
+            label.setMaxSize(Double.MAX_VALUE, barHeight);
+            final int index = i;
+            label.setOnMousePressed(event -> {
+                currentTabIndex = index;
+                markSceneDirty();
+                root.requestFocus();
+                event.consume();
+            });
+            tabBar.getChildren().add(label);
+        }
+    }
+
+    // ---- Input ----------------------------------------------------------------------
+
+    private void handleMousePressed(TerminalPane pane, MouseEvent event) {
+        root.requestFocus();
+        focus(pane);
+        pressedButton = mouseButton(event);
+        mouseButtonPressed = true;
+        MouseTarget target = mouseTarget(pane);
+        if (target == null) {
+            return;
+        }
+        send(pane, target, MouseInput.press(pressedButton, localX(event.getX(), target), localY(event.getY(), target), modifiers(event)), true, event);
+    }
+
+    private void handleMouseReleased(TerminalPane pane, MouseEvent event) {
+        MouseButton button = pressedButton == MouseButton.UNKNOWN ? mouseButton(event) : pressedButton;
+        MouseTarget target = mouseTarget(pane);
+        if (target != null) {
+            send(pane, target, MouseInput.release(button, localX(event.getX(), target), localY(event.getY(), target), modifiers(event)), false, event);
+        }
+        mouseButtonPressed = false;
+        pressedButton = MouseButton.UNKNOWN;
+    }
+
+    private void handleMouseDragged(TerminalPane pane, MouseEvent event) {
+        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(), target), localY(event.getY(), target), modifiers(event)), true, event);
+    }
+
+    private void handleMouseMoved(TerminalPane pane, MouseEvent event) {
+        MouseTarget target = mouseTarget(pane);
+        if (target == null) {
+            return;
+        }
+        send(pane, target, MouseInput.motion(localX(event.getX(), target), localY(event.getY(), target), modifiers(event)), mouseButtonPressed, event);
+    }
+
+    private void handleScroll(TerminalPane pane, ScrollEvent event) {
+        root.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) {
+            double ex = localX(event.getX(), target);
+            double ey = localY(event.getY(), 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) {
+            pane.scrollViewport(direction > 0 ? -rows : rows);
+            event.consume();
+        }
+    }
+
+    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 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);
+    }
+
+    private static double localX(double nodeX, MouseTarget target) {
+        return clamp(nodeX - TerminalMetrics.PADDING, 0.0, target.screenWidth() - 1.0);
+    }
+
+    private static double localY(double nodeY, MouseTarget target) {
+        return clamp(nodeY - 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;
+        };
+    }
+
+    private record MouseTarget(MouseEncoderSize size, long screenWidth, long screenHeight) {
+    }
+}

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

@@ -0,0 +1,401 @@
+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.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 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();
+
+    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 SIGKILL = 9;
+    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 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 Object writeLock = new Object();
+    private final int masterFd;
+    private final int pid;
+    private volatile boolean closed;
+
+    private LinuxPty(int masterFd, int pid) {
+        this.masterFd = masterFd;
+        this.pid = pid;
+    }
+
+    /**
+     * 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
+     */
+    public static LinuxPty spawn(String[] argv, Map<String, String> environment, String workingDirectory) {
+        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));
+                } 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) {
+            try (Arena a = Arena.ofConfined()) {
+                MemorySegment buf = a.allocate(data.length);
+                MemorySegment.copy(data, 0, buf, ValueLayout.JAVA_BYTE, 0, data.length);
+                long offset = 0;
+                while (offset < data.length) {
+                    long n = callLong(WRITE, masterFd, buf.asSlice(offset), data.length - offset);
+                    if (n < 0) {
+                        throw new IllegalStateException("write to pty failed");
+                    }
+                    offset += n;
+                }
+            }
+        }
+    }
+
+    /** 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 (closed) {
+            return;
+        }
+        closed = true;
+        callKill(pid, SIGHUP);
+        callInt(CLOSE, masterFd);
+        reap();
+        arena.close();
+    }
+
+    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

@@ -2,6 +2,7 @@ package com.gregor.jprototerm;
 
 import javafx.animation.AnimationTimer;
 import javafx.application.Application;
+import javafx.application.Platform;
 import javafx.scene.Scene;
 import javafx.scene.control.ButtonType;
 import javafx.scene.control.ComboBox;
@@ -11,78 +12,91 @@ import javafx.scene.control.Spinner;
 import javafx.scene.control.SpinnerValueFactory;
 import javafx.scene.input.KeyEvent;
 import javafx.scene.layout.GridPane;
-import javafx.scene.layout.StackPane;
 import javafx.scene.text.Font;
 import javafx.stage.Stage;
 
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
 public final class Main extends Application {
-    private TerminalWorkspace workspace;
+    private Compositor compositor;
-    private TerminalCanvasView terminalView;
+    private TerminalMetrics metrics;
     private AppConfig config;
 
     @Override
     public void start(Stage stage) {
         config = AppConfig.load();
 
-        workspace = new TerminalWorkspace(config);
+        metrics = new TerminalMetrics(config.fontFamily(), config.fontSize());
-        terminalView = new TerminalCanvasView(workspace, config);
+        compositor = new Compositor(config, metrics);
 
-        StackPane root = new StackPane(terminalView.canvas());
+        Scene scene = new Scene(compositor.node(), config.windowWidth(), config.windowHeight());
-        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, this::handlePressed);
         scene.addEventFilter(KeyEvent.KEY_TYPED, event -> handleTyped(event));
 
         new AnimationTimer() {
             @Override
             public void handle(long now) {
-                terminalView.render();
+                compositor.render();
             }
         }.start();
 
         stage.setTitle("jprototerm");
         stage.setScene(scene);
         stage.setOnCloseRequest(event -> {
-            workspace.close();
+            compositor.close();
         });
         stage.show();
-        terminalView.canvas().requestFocus();
+        compositor.requestFocus();
     }
 
     private void handlePressed(KeyEvent event) {
         if (config.keybindings().get("navigate_left").matches(event)) {
-            workspace.navigate(Direction.LEFT);
+            compositor.navigate(Direction.LEFT);
             event.consume();
         } else if (config.keybindings().get("navigate_down").matches(event)) {
-            workspace.navigate(Direction.DOWN);
+            compositor.navigate(Direction.DOWN);
             event.consume();
         } else if (config.keybindings().get("navigate_up").matches(event)) {
-            workspace.navigate(Direction.UP);
+            compositor.navigate(Direction.UP);
             event.consume();
         } else if (config.keybindings().get("navigate_right").matches(event)) {
-            workspace.navigate(Direction.RIGHT);
+            compositor.navigate(Direction.RIGHT);
             event.consume();
         } else if (config.keybindings().get("toggle_floating").matches(event)) {
-            workspace.toggleFloating();
+            compositor.toggleFloating();
             event.consume();
-        } else if (config.keybindings().get("new_floating").matches(event)) {
+        } else if (config.keybindings().get("new_pane").matches(event)) {
-            workspace.createFloatingPane();
+            compositor.createPane();
-            event.consume();
-        } else if (config.keybindings().get("next_floating").matches(event)) {
-            workspace.nextFloatingPane();
             event.consume();
         } else if (config.keybindings().get("close_pane").matches(event)) {
-            workspace.closeActivePane();
+            compositor.closeActivePane();
+            event.consume();
+            if (compositor.isEmpty()) {
+                // Closing the last pane quits the app.
+                compositor.close();
+                Platform.exit();
+            }
+        } else if (config.keybindings().get("new_tab").matches(event)) {
+            compositor.newTab();
+            event.consume();
+        } else if (config.keybindings().get("previous_tab").matches(event)) {
+            compositor.previousTab();
+            event.consume();
+        } else if (config.keybindings().get("next_tab").matches(event)) {
+            compositor.nextTab();
             event.consume();
         } else if (config.keybindings().get("open_font_selector").matches(event)) {
             openFontSelector();
             event.consume();
+        } else if (config.keybindings().get("open_scrollback").matches(event)) {
+            openScrollbackInEditor();
+            event.consume();
         } else {
             String encoded = KeyEncoder.encode(event);
             if (encoded != null) {
-                workspace.activePane().send(encoded);
+                compositor.activePane().send(encoded);
                 event.consume();
             }
         }
@@ -95,7 +109,7 @@ public final class Main extends Application {
 
         String text = event.getCharacter();
         if (text != null && !text.isEmpty() && text.charAt(0) >= 0x20 && text.charAt(0) != 0x7f) {
-            workspace.activePane().send(text);
+            compositor.activePane().send(text);
             event.consume();
         }
     }
@@ -138,11 +152,39 @@ public final class Main extends Application {
                     double selectedSize = size.getValue();
                     config = config.withFont(selectedFamily.trim(), selectedSize);
                     config.save();
-                    terminalView.setFont(config.fontFamily(), config.fontSize());
+                    compositor.setFont(config.fontFamily(), config.fontSize());
-                    terminalView.canvas().requestFocus();
+                    compositor.requestFocus();
                 });
     }
 
+    private void openScrollbackInEditor() {
+        try {
+            Path file = Files.createTempFile("jprototerm-scrollback-", ".txt");
+            Files.writeString(file, compositor.activePane().scrollbackText());
+            file.toFile().deleteOnExit();
+
+            compositor.activePane().send(scrollbackEditorCommand(file) + "\r");
+        } catch (IOException ex) {
+            System.err.println("Could not open scrollback in editor: " + ex.getMessage());
+        }
+    }
+
+    private String scrollbackEditorCommand(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 static String shellQuote(String value) {
+        return "'" + value.replace("'", "'\"'\"'") + "'";
+    }
+
     public static void main(String[] args) {
         System.setProperty("prism.order", System.getProperty("prism.order", "es2,sw"));
         launch(Main.class, args);

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

@@ -0,0 +1,79 @@
+package com.gregor.jprototerm;
+
+/**
+ * Lightweight render profiler, disabled unless {@code -Djprototerm.profile=true} (or the
+ * {@code JPROTOTERM_PROFILE=1} environment variable) is set. It accumulates wall-clock nanos
+ * into a handful of buckets and prints aggregate per-frame stats to stderr every
+ * {@code jprototerm.profile.frames} render invocations (default 120).
+ *
+ * <p>All render work runs on the JavaFX application thread, so the accumulators are plain
+ * fields with no synchronization.
+ *
+ * <p>Caveat: JavaFX canvas drawing is deferred to the QuantumRenderer thread, so the
+ * {@link #DRAW} bucket measures only the cost of <em>recording</em> draw commands, not the
+ * GPU paint. Pair this with {@code -Djavafx.pulseLogger=true} to see the render-thread side.
+ */
+final class RenderProfiler {
+    static final int SNAPSHOT = 0;
+    static final int FINGERPRINT = 1;
+    static final int DRAW = 2;
+    static final int FRAME = 3;
+    static final int UPDATE = 4;
+    static final int MARSHAL = 5;
+    private static final int BUCKETS = 6;
+    private static final String[] NAMES =
+            {"snapshot", "fingerprint", "draw", "frame-total", "update", "marshal"};
+
+    private static final boolean ENABLED =
+            Boolean.getBoolean("jprototerm.profile") || "1".equals(System.getenv("JPROTOTERM_PROFILE"));
+    private static final int DUMP_FRAMES = Integer.getInteger("jprototerm.profile.frames", 120);
+
+    private static final long[] totalNanos = new long[BUCKETS];
+    private static final long[] counts = new long[BUCKETS];
+    private static int frames;
+
+    private RenderProfiler() {
+    }
+
+    static boolean enabled() {
+        return ENABLED;
+    }
+
+    /** Returns a start timestamp, or 0 when profiling is disabled. */
+    static long start() {
+        return ENABLED ? System.nanoTime() : 0L;
+    }
+
+    /** Records the time elapsed since {@code startNanos} into {@code bucket}. */
+    static void stop(int bucket, long startNanos) {
+        if (!ENABLED) {
+            return;
+        }
+        totalNanos[bucket] += System.nanoTime() - startNanos;
+        counts[bucket]++;
+    }
+
+    /** Marks the end of one render invocation; dumps and resets every {@code DUMP_FRAMES}. */
+    static void frame() {
+        if (!ENABLED) {
+            return;
+        }
+        if (++frames < DUMP_FRAMES) {
+            return;
+        }
+        dump();
+    }
+
+    private static void dump() {
+        StringBuilder sb = new StringBuilder(192);
+        sb.append("[render-profile] ").append(frames).append(" renders");
+        for (int i = 0; i < BUCKETS; i++) {
+            double totalMs = totalNanos[i] / 1_000_000.0;
+            sb.append(String.format(" | %s %.3fms/f (n=%d)", NAMES[i], totalMs / frames, counts[i]));
+            totalNanos[i] = 0;
+            counts[i] = 0;
+        }
+        System.err.println(sb);
+        frames = 0;
+    }
+}

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

@@ -1,12 +1,5 @@
 package com.gregor.jprototerm;
 
-import com.pty4j.PtyProcess;
-import com.pty4j.PtyProcessBuilder;
-import com.pty4j.WinSize;
-import javafx.application.Platform;
-
-import java.io.IOException;
-import java.io.OutputStream;
 import java.nio.charset.StandardCharsets;
 import java.util.HashMap;
 import java.util.Map;
@@ -14,14 +7,12 @@ import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
 public final class ShellSession implements AutoCloseable {
-    private final PtyProcess process;
+    private final LinuxPty pty;
-    private final OutputStream stdin;
     private final ExecutorService reader;
     private volatile boolean closed;
 
-    private ShellSession(PtyProcess process) {
+    private ShellSession(LinuxPty pty) {
-        this.process = process;
+        this.pty = pty;
-        this.stdin = process.getOutputStream();
         this.reader = Executors.newSingleThreadExecutor(runnable -> {
             Thread thread = new Thread(runnable, "shell-output-reader");
             thread.setDaemon(true);
@@ -29,25 +20,51 @@ public final class ShellSession implements AutoCloseable {
         });
     }
 
-    public static ShellSession start(String shell, TerminalPane pane, int columns, int rows) {
+    public static ShellSession start(String shell, Map<String, String> envOverride, TerminalPane pane, int columns, int rows) {
         try {
             Map<String, String> environment = new HashMap<>(System.getenv());
             environment.put("TERM", "xterm-kitty");
             environment.put("COLORTERM", "truecolor");
+            sanitizeWrapperEnvironment(environment);
+            environment.putAll(envOverride);
 
-            PtyProcess process = new PtyProcessBuilder(new String[] {shell, "-i"})
+            LinuxPty pty = LinuxPty.spawn(
-                    .setEnvironment(environment)
+                    new String[] {shell, "-i"},
-                    .setInitialColumns(columns)
+                    environment,
-                    .setInitialRows(rows)
+                    System.getProperty("user.home"));
-                    .setDirectory(System.getProperty("user.home"))
+            ShellSession session = new ShellSession(pty);
-                    .start();
+            session.resize(columns, rows);
-            return new ShellSession(process);
+            return session;
-        } catch (IOException ex) {
+        } catch (RuntimeException ex) {
             pane.write("failed to start shell: " + ex.getMessage() + "\r\n");
             throw new IllegalStateException("Could not start shell " + shell, ex);
         }
     }
 
+    /**
+     * 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");
+    }
+
     public void startReading(TerminalPane pane) {
         reader.submit(() -> readOutput(pane));
     }
@@ -56,7 +73,7 @@ public final class ShellSession implements AutoCloseable {
         if (closed) {
             return;
         }
-        process.setWinSize(new WinSize(columns, rows));
+        pty.setWinSize(columns, rows);
     }
 
     public void send(String text) {
@@ -68,31 +85,32 @@ public final class ShellSession implements AutoCloseable {
             return;
         }
         try {
-            stdin.write(bytes);
+            pty.write(bytes);
-            stdin.flush();
+        } catch (RuntimeException ex) {
-        } catch (IOException ex) {
             close();
         }
     }
 
     private void readOutput(TerminalPane pane) {
-        byte[] buffer = new byte[8192];
+        byte[] buffer = new byte[65536];
         try {
             int read;
-            while ((read = process.getInputStream().read(buffer)) != -1) {
+            while ((read = pty.read(buffer)) != -1) {
-                if (!closed) {
+                if (closed) {
+                    break;
+                }
                 byte[] bytes = new byte[read];
                 System.arraycopy(buffer, 0, bytes, 0, read);
-                    Platform.runLater(() -> {
+                // Feed the terminal model straight from the reader thread. terminal access is
-                        if (!closed) {
+                // 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) {
-                }
-            }
-        } catch (IOException ex) {
             if (!closed) {
-                Platform.runLater(() -> pane.write("\r\nshell output stopped: " + ex.getMessage() + "\r\n"));
+                pane.write("\r\nshell output stopped: " + ex.getMessage() + "\r\n");
             }
         }
     }
@@ -101,6 +119,6 @@ public final class ShellSession implements AutoCloseable {
     public void close() {
         closed = true;
         reader.shutdownNow();
-        process.destroy();
+        pty.close();
     }
 }

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

@@ -0,0 +1,288 @@
+package com.gregor.jprototerm;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+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 {
+    private final AppConfig config;
+    private final TerminalMetrics metrics;
+    private final List<TerminalPane> tiled = new ArrayList<>();
+    private final List<TerminalPane> floating = new ArrayList<>();
+    private boolean floatingVisible;
+    private TerminalPane active;
+    // 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;
+    // 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 long contentVersion;
+
+    Tab(AppConfig config, TerminalMetrics metrics) {
+        this.config = config;
+        this.metrics = metrics;
+        this.lastWidth = config.windowWidth();
+        this.lastHeight = config.windowHeight();
+        TerminalPane first = openPane(false);
+        tiled.add(first);
+        active = first;
+    }
+
+    TerminalPane activePane() {
+        return active;
+    }
+
+    boolean isEmpty() {
+        return tiled.isEmpty() && floating.isEmpty();
+    }
+
+    long contentVersion() {
+        return contentVersion;
+    }
+
+    /**
+     * 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);
+        for (TerminalPane pane : floating) {
+            if (pane != active) {
+                ordered.add(pane);
+            }
+        }
+        if (floating.contains(active)) {
+            ordered.add(active); // active floating pane on top
+        }
+        return List.copyOf(ordered);
+    }
+
+    List<TerminalPane> allPanes() {
+        List<TerminalPane> all = new ArrayList<>(tiled.size() + floating.size());
+        all.addAll(tiled);
+        all.addAll(floating);
+        return List.copyOf(all);
+    }
+
+    boolean isActive(TerminalPane pane) {
+        return pane != null && pane == active;
+    }
+
+    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(420, width * 0.58);
+        double floatingHeight = Math.max(260, availHeight * 0.58);
+        for (int i = 0; i < floating.size(); i++) {
+            double offset = i * 28.0;
+            floating.get(i).bounds(
+                    Math.min(width - floatingWidth - 12.0, ((width - floatingWidth) / 2.0) + offset),
+                    Math.min(height - floatingHeight - 12.0, topInset + ((availHeight - floatingHeight) / 2.0) + offset),
+                    floatingWidth,
+                    floatingHeight);
+        }
+    }
+
+    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.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 closeActivePane() {
+        TerminalPane closing = active;
+        boolean wasFloating = floating.remove(closing);
+        if (!wasFloating) {
+            tiled.remove(closing);
+        }
+        if (closing == lastFocusedFloating) {
+            lastFocusedFloating = null;
+        }
+        closing.close();
+
+        if (tiled.isEmpty() && floating.isEmpty()) {
+            active = null; // tab is now empty; the compositor drops it
+            return;
+        }
+
+        // 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 = null;
+                if (!floating.isEmpty()) {
+                    lastFocusedFloating = floating.isEmpty() ? null : floating.get(nextFocussed);
+                }
+            }
+        }
+        if (floating.isEmpty()) {
+            floatingVisible = false;
+        }
+
+        setActive(wasFloating && floatingVisible ? floating.get(floating.size() - 1) : tiled.get(0));
+    }
+
+    private void setActive(TerminalPane pane) {
+        active = pane;
+        if (floating.contains(pane)) {
+            lastFocusedFloating = pane;
+        }
+    }
+
+    private void createFloatingPane() {
+        TerminalPane pane = openPane(true);
+        floating.add(pane);
+        floatingVisible = true;
+        setActive(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++;
+    }
+
+    private TerminalPane openPane(boolean asFloating) {
+        double availHeight = lastHeight - lastTopInset;
+        double widthPx;
+        double heightPx;
+        if (asFloating) {
+            widthPx = Math.max(420, lastWidth * 0.58);
+            heightPx = Math.max(260, availHeight * 0.58);
+        } else {
+            // A new tiled pane joins the row, so each gets 1/(n+1) of the width.
+            widthPx = lastWidth / (tiled.size() + 1);
+            heightPx = availHeight;
+        }
+        return TerminalPane.create(config, metrics, this::markContentChanged, widthPx, heightPx);
+    }
+
+    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();
+    }
+}

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

@@ -1,457 +0,0 @@
-package com.gregor.jprototerm;
-
-import dev.jlibghostty.KittyImageCompression;
-import dev.jlibghostty.KittyImageFormat;
-import dev.jlibghostty.KittyImageSnapshot;
-import dev.jlibghostty.KittyPlacement;
-import dev.jlibghostty.KittyRenderInfo;
-import dev.jlibghostty.KeyModifiers;
-import dev.jlibghostty.MouseButton;
-import dev.jlibghostty.MouseEncoderSize;
-import dev.jlibghostty.MouseInput;
-import dev.jlibghostty.RenderCell;
-import dev.jlibghostty.RenderColor;
-import dev.jlibghostty.RenderCursorStyle;
-import dev.jlibghostty.RenderRow;
-import dev.jlibghostty.RenderStateSnapshot;
-import javafx.scene.canvas.Canvas;
-import javafx.scene.canvas.GraphicsContext;
-import javafx.scene.image.Image;
-import javafx.scene.image.PixelFormat;
-import javafx.scene.image.WritableImage;
-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.Text;
-
-import java.io.ByteArrayInputStream;
-import java.util.HashMap;
-import java.util.Map;
-
-public final class TerminalCanvasView {
-    private static final Color DEFAULT_FOREGROUND = Color.rgb(225, 229, 235);
-    private static final Color SELECTED_BACKGROUND = Color.rgb(52, 92, 140);
-
-    private final Canvas canvas = new Canvas();
-    private final TerminalWorkspace workspace;
-    private final AppConfig config;
-    private final Map<Long, Image> kittyImageCache = new HashMap<>();
-    private String fontFamily;
-    private double fontSize;
-    private boolean mouseButtonPressed;
-    private MouseButton pressedButton = MouseButton.UNKNOWN;
-
-    public TerminalCanvasView(TerminalWorkspace workspace, AppConfig config) {
-        this.workspace = workspace;
-        this.config = config;
-        this.fontFamily = config.fontFamily();
-        this.fontSize = config.fontSize();
-        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;
-    }
-
-    public void setFont(String family, double size) {
-        this.fontFamily = family;
-        this.fontSize = size;
-    }
-
-    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.LCD);
-
-        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(fontFamily, fontSize);
-        gc.setFont(font);
-
-        FontMetrics metrics = measureFontMetrics(font);
-        int columns = Math.max(1, (int) ((pane.width() - 24.0) / metrics.cellWidth));
-        int rows = Math.max(1, (int) ((pane.height() - 24.0) / metrics.lineHeight));
-        pane.resize(columns, rows, (int) Math.round(metrics.cellWidth), (int) Math.round(metrics.lineHeight));
-
-        double left = pane.x() + 12.0;
-        double top = pane.y() + 12.0;
-        double baseline = top + metrics.baselineOffset;
-
-        RenderStateSnapshot snapshot = pane.renderSnapshot();
-        if (snapshot != null) {
-            for (RenderRow row : snapshot.renderRows()) {
-                drawRow(gc, row, left, top, baseline, metrics.cellWidth, metrics.lineHeight);
-            }
-        }
-
-        if (snapshot != null) {
-            drawCursor(gc, snapshot, left, top, metrics.cellWidth, metrics.lineHeight);
-        }
-
-        if (config.kittyGraphics()) {
-            drawKittyGraphics(gc, pane, left, top, metrics.cellWidth, metrics.lineHeight);
-        }
-        gc.restore();
-    }
-
-    private static FontMetrics measureFontMetrics(Font font) {
-        Text text = new Text("┃MgÅjy");
-        text.setFont(font);
-        double lineHeight = Math.max(1.0, text.getLayoutBounds().getHeight());
-        double baselineOffset = -text.getLayoutBounds().getMinY();
-
-        String sample = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-        Text cell = new Text(sample);
-        cell.setFont(font);
-        double cellWidth = Math.max(1.0, cell.getLayoutBounds().getWidth() / sample.length());
-        return new FontMetrics(cellWidth, lineHeight, baselineOffset);
-    }
-
-    private void handleMousePressed(MouseEvent event) {
-        canvas.requestFocus();
-        TerminalPane pane = paneAt(event.getX(), event.getY());
-        if (pane == null) {
-            return;
-        }
-
-        workspace.focus(pane);
-        pressedButton = mouseButton(event);
-        mouseButtonPressed = true;
-        sendMouse(pane, MouseInput.press(pressedButton, eventX(pane, event.getX()), eventY(pane, event.getY()), modifiers(event)), true, event);
-    }
-
-    private void handleMouseReleased(MouseEvent event) {
-        TerminalPane pane = paneAt(event.getX(), event.getY());
-        if (pane == null) {
-            pane = workspace.activePane();
-        }
-
-        MouseButton button = pressedButton == MouseButton.UNKNOWN ? mouseButton(event) : pressedButton;
-        sendMouse(pane, MouseInput.release(button, eventX(pane, event.getX()), eventY(pane, event.getY()), 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 = workspace.activePane();
-        }
-
-        MouseButton button = pressedButton == MouseButton.UNKNOWN ? mouseButton(event) : pressedButton;
-        sendMouse(pane, MouseInput.drag(button, eventX(pane, event.getX()), eventY(pane, event.getY()), modifiers(event)), true, event);
-    }
-
-    private void handleMouseMoved(MouseEvent event) {
-        TerminalPane pane = paneAt(event.getX(), event.getY());
-        if (pane == null) {
-            return;
-        }
-
-        sendMouse(pane, MouseInput.motion(eventX(pane, event.getX()), eventY(pane, event.getY()), modifiers(event)), mouseButtonPressed, event);
-    }
-
-    private void handleScroll(ScrollEvent event) {
-        TerminalPane pane = paneAt(event.getX(), event.getY());
-        if (pane == null) {
-            return;
-        }
-
-        canvas.requestFocus();
-        workspace.focus(pane);
-        int direction = scrollDirection(event);
-        if (direction == 0) {
-            return;
-        }
-
-        MouseButton wheelButton = direction > 0 ? MouseButton.FOUR : MouseButton.FIVE;
-        int rows = scrollRows(event);
-        boolean sent = false;
-        for (int i = 0; i < rows; i++) {
-            sent |= sendMouse(
-                    pane,
-                    MouseInput.press(wheelButton, eventX(pane, event.getX()), eventY(pane, event.getY()), modifiers(event)),
-                    mouseButtonPressed,
-                    event
-            );
-        }
-        if (!sent) {
-            pane.scrollViewport(direction > 0 ? -rows : rows);
-            event.consume();
-        }
-    }
-
-    private boolean sendMouse(TerminalPane pane, MouseInput input, boolean anyButtonPressed, InputEvent event) {
-        MouseTarget target = mouseTarget(pane);
-        if (target == null) {
-            return false;
-        }
-
-        boolean sent = pane.sendMouse(input, target.size(), anyButtonPressed);
-        if (sent) {
-            event.consume();
-        }
-        return sent;
-    }
-
-    private TerminalPane paneAt(double x, double y) {
-        java.util.List<TerminalPane> panes = workspace.panes();
-        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() <= 24.0 || pane.height() <= 24.0) {
-            return null;
-        }
-
-        FontMetrics metrics = measureFontMetrics(Font.font(fontFamily, fontSize));
-        int columns = Math.max(1, (int) ((pane.width() - 24.0) / metrics.cellWidth));
-        int rows = Math.max(1, (int) ((pane.height() - 24.0) / metrics.lineHeight));
-        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);
-    }
-
-    private double eventX(TerminalPane pane, double canvasX) {
-        MouseTarget target = mouseTarget(pane);
-        if (target == null) {
-            return 0.0;
-        }
-        return clamp(canvasX - pane.x() - 12.0, 0.0, target.screenWidth() - 1.0);
-    }
-
-    private double eventY(TerminalPane pane, double canvasY) {
-        MouseTarget target = mouseTarget(pane);
-        if (target == null) {
-            return 0.0;
-        }
-        return clamp(canvasY - pane.y() - 12.0, 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;
-        };
-    }
-
-    private static void drawRow(
-            GraphicsContext gc,
-            RenderRow row,
-            double left,
-            double top,
-            double baseline,
-            double cellWidth,
-            double lineHeight
-    ) {
-        for (RenderCell cell : row.cells()) {
-            double x = left + (cell.column() * cellWidth);
-            double cellTop = top + (row.row() * lineHeight);
-            cell.background().ifPresent(background -> {
-                gc.setFill(toFxColor(background));
-                fillCellRect(gc, x, cellTop, cellWidth, lineHeight);
-            });
-            if (cell.selected()) {
-                gc.setFill(SELECTED_BACKGROUND);
-                fillCellRect(gc, x, cellTop, cellWidth, lineHeight);
-            }
-            if (cell.codepoints().length == 0) {
-                continue;
-            }
-
-            double y = baseline + (row.row() * lineHeight);
-            Color foreground = cell.foreground().map(TerminalCanvasView::toFxColor).orElse(DEFAULT_FOREGROUND);
-            gc.setFill(foreground);
-            gc.fillText(cell.text(), x, y);
-        }
-    }
-
-    private static void fillCellRect(GraphicsContext gc, double x, double y, double width, double height) {
-        double x1 = Math.floor(x);
-        double y1 = Math.floor(y);
-        double x2 = Math.ceil(x + width);
-        double y2 = Math.ceil(y + height);
-        gc.fillRect(x1, y1, Math.max(1.0, x2 - x1), Math.max(1.0, y2 - y1));
-    }
-
-    private static Color toFxColor(RenderColor color) {
-        return Color.rgb(color.red(), color.green(), color.blue());
-    }
-
-    private static void drawCursor(GraphicsContext gc, RenderStateSnapshot snapshot, double left, double top, double cellWidth, double lineHeight) {
-        if (!snapshot.cursorVisible() || !snapshot.cursorViewportHasValue()) {
-            return;
-        }
-
-        double x = left + (snapshot.cursorViewportX() * cellWidth);
-        double y = top + (snapshot.cursorViewportY() * lineHeight);
-        gc.setStroke(Color.rgb(225, 229, 235));
-        gc.setFill(Color.rgb(225, 229, 235, 0.28));
-        gc.setLineWidth(1.5);
-
-        RenderCursorStyle style = snapshot.cursorStyle();
-        if (style == RenderCursorStyle.BAR) {
-            gc.strokeLine(x + 0.5, y + 2.0, x + 0.5, y + lineHeight - 2.0);
-        } else if (style == RenderCursorStyle.UNDERLINE) {
-            gc.strokeLine(x + 1.0, y + lineHeight - 2.0, x + cellWidth - 1.0, y + lineHeight - 2.0);
-        } else if (style == RenderCursorStyle.BLOCK) {
-            gc.fillRect(x + 0.5, y + 1.0, Math.max(1.0, cellWidth - 1.0), Math.max(1.0, lineHeight - 2.0));
-        } else {
-            gc.strokeRect(x + 0.5, y + 1.0, Math.max(1.0, cellWidth - 1.0), Math.max(1.0, lineHeight - 2.0));
-        }
-    }
-
-    private void drawKittyGraphics(GraphicsContext gc, TerminalPane pane, double originX, double originY, double cellWidth, double lineHeight) {
-        pane.kittyGraphics().ifPresent(graphics -> {
-            for (KittyPlacement placement : graphics.placements()) {
-                Image image = imageFor(placement);
-                if (image == null) {
-                    continue;
-                }
-
-                KittyRenderInfo renderInfo = placement.renderInfo().orElse(null);
-                double x = originX;
-                double y = originY;
-                double width = image.getWidth();
-                double height = image.getHeight();
-
-                if (renderInfo != null) {
-                    x += renderInfo.viewportColumn() * cellWidth;
-                    y += renderInfo.viewportRow() * lineHeight;
-                    width = renderInfo.gridColumns() > 0 ? renderInfo.gridColumns() * cellWidth : renderInfo.pixelWidth();
-                    height = renderInfo.gridRows() > 0 ? renderInfo.gridRows() * lineHeight : renderInfo.pixelHeight();
-                } else {
-                    width = placement.columns() > 0 ? placement.columns() * cellWidth : width;
-                    height = placement.rows() > 0 ? placement.rows() * lineHeight : height;
-                }
-
-                gc.drawImage(image, x + placement.xOffset(), y + placement.yOffset(), width, height);
-            }
-        });
-    }
-
-    private Image imageFor(KittyPlacement placement) {
-        return placement.image()
-                .map(snapshot -> kittyImageCache.computeIfAbsent(snapshot.id(), ignored -> decodeImage(snapshot)))
-                .orElse(null);
-    }
-
-    private Image decodeImage(KittyImageSnapshot snapshot) {
-        if (snapshot.compression() != KittyImageCompression.NONE) {
-            return null;
-        }
-
-        if (snapshot.format() == KittyImageFormat.PNG) {
-            return new Image(new ByteArrayInputStream(snapshot.data()));
-        }
-
-        int width = Math.toIntExact(snapshot.width());
-        int height = Math.toIntExact(snapshot.height());
-        WritableImage image = new WritableImage(width, height);
-        byte[] data = snapshot.data();
-
-        if (snapshot.format() == KittyImageFormat.RGBA) {
-            image.getPixelWriter().setPixels(0, 0, width, height, PixelFormat.getByteBgraInstance(), rgbaToBgra(data), 0, width * 4);
-        } else if (snapshot.format() == KittyImageFormat.RGB) {
-            image.getPixelWriter().setPixels(0, 0, width, height, PixelFormat.getByteRgbInstance(), data, 0, width * 3);
-        }
-        return image;
-    }
-
-    private static byte[] rgbaToBgra(byte[] rgba) {
-        byte[] bgra = new byte[rgba.length];
-        for (int i = 0; i + 3 < rgba.length; i += 4) {
-            bgra[i] = rgba[i + 2];
-            bgra[i + 1] = rgba[i + 1];
-            bgra[i + 2] = rgba[i];
-            bgra[i + 3] = rgba[i + 3];
-        }
-        return bgra;
-    }
-
-    private record FontMetrics(double cellWidth, double lineHeight, double baselineOffset) {
-    }
-
-    private record MouseTarget(MouseEncoderSize size, long screenWidth, long screenHeight) {
-    }
-}

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

@@ -0,0 +1,86 @@
+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;
+
+    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;
+    }
+
+    /** 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,27 +1,39 @@
 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 dev.jlibghostty.DeviceAttributes;
 
 import java.util.Optional;
-import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.atomic.AtomicLong;
 
+/**
+ * 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; {@link TerminalPaneNode}
+ * reads snapshots from it and represents the visible rows and kitty graphics as JavaFX nodes.
+ */
 public final class TerminalPane implements AutoCloseable {
     private final Terminal terminal;
+    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 MouseEncoder mouseEncoder = new MouseEncoder();
-    private final AtomicReference<RenderStateSnapshot> renderSnapshot = new AtomicReference<>();
+    // 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 ShellSession session;
-    private boolean floating;
-    private boolean visible = true;
     private double x;
     private double y;
     private double width;
@@ -30,21 +42,48 @@ public final class TerminalPane implements AutoCloseable {
     private int rows;
     private int pixelWidth;
     private int pixelHeight;
+    private final AtomicLong contentVersion = new AtomicLong();
+    private volatile long snapshotVersion = -1;
 
-    private TerminalPane(Terminal terminal, int columns, int rows) {
+    private TerminalPane(Terminal terminal, TerminalMetrics metrics, boolean kittyEnabled,
+            Runnable onContentChange, int columns, int rows) {
         this.terminal = terminal;
+        this.metrics = metrics;
+        this.kittyEnabled = kittyEnabled;
+        this.onContentChange = onContentChange;
         this.columns = columns;
         this.rows = rows;
     }
 
-    public static TerminalPane create(int columns, int rows, long maxScrollback) {
+    /**
-        Terminal terminal = Ghostty.open(new TerminalOptions(columns, rows, maxScrollback));
+     * 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.
+     */
+    public static TerminalPane create(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, columns, rows);
+        TerminalPane pane = new TerminalPane(terminal, metrics, config.kittyGraphics(), onContentChange, columns, rows);
         pane.refresh();
+        pane.attach(ShellSession.start(config.shell(), config.envOverride(), pane, columns, rows));
         return pane;
     }
 
+    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);
@@ -59,17 +98,6 @@ public final class TerminalPane implements AutoCloseable {
         }
     }
 
-    public 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 send(String text) {
         scrollViewportToBottom();
         if (session != null) {
@@ -103,15 +131,74 @@ public final class TerminalPane implements AutoCloseable {
         }
     }
 
-    public void scrollViewportToBottom() {
+    private void scrollViewportToBottom() {
         synchronized (terminal) {
             terminal.scrollViewport(ScrollViewport.bottom());
             refresh();
         }
     }
 
-    public RenderStateSnapshot renderSnapshot() {
+    /**
-        return renderSnapshot.get();
+     * 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.
+     */
+    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).
+     */
+    public RenderStateSnapshot snapshotFull() {
+        return takeSnapshot(true);
+    }
+
+    private RenderStateSnapshot takeSnapshot(boolean full) {
+        synchronized (terminal) {
+            long version = contentVersion.get();
+            if (full) {
+                long updateStart = RenderProfiler.start();
+                renderState.update(terminal);
+                RenderProfiler.stop(RenderProfiler.UPDATE, updateStart);
+                long marshalStart = RenderProfiler.start();
+                cachedSnapshot = renderState.snapshot();
+                RenderProfiler.stop(RenderProfiler.MARSHAL, marshalStart);
+                renderState.resetDirty();
+                snapshotVersion = version;
+            } else if (snapshotVersion != version) {
+                long updateStart = RenderProfiler.start();
+                renderState.update(terminal);
+                RenderProfiler.stop(RenderProfiler.UPDATE, updateStart);
+                long marshalStart = RenderProfiler.start();
+                cachedSnapshot = renderState.snapshotIncremental();
+                RenderProfiler.stop(RenderProfiler.MARSHAL, marshalStart);
+                renderState.resetDirty();
+                snapshotVersion = version;
+            }
+            return cachedSnapshot;
+        }
+    }
+
+    public String scrollbackText() {
+        synchronized (terminal) {
+            return terminal.text();
+        }
+    }
+
+    /** This pane's own content revision, bumped on every change (see {@link #refresh()}). */
+    public long contentVersion() {
+        return contentVersion.get();
+    }
+
+    long snapshotVersion() {
+        return snapshotVersion;
+    }
+
+    public boolean kittyEnabled() {
+        return kittyEnabled;
     }
 
     public Optional<KittyGraphics> kittyGraphics() {
@@ -120,22 +207,6 @@ public final class TerminalPane implements AutoCloseable {
         }
     }
 
-    public boolean floating() {
-        return floating;
-    }
-
-    public void setFloating(boolean floating) {
-        this.floating = floating;
-    }
-
-    public boolean visible() {
-        return visible;
-    }
-
-    public void setVisible(boolean visible) {
-        this.visible = visible;
-    }
-
     public double x() {
         return x;
     }
@@ -159,7 +230,14 @@ public final class TerminalPane implements AutoCloseable {
         this.height = height;
     }
 
-    public void resize(int columns, int rows, int pixelWidth, int pixelHeight) {
+    /** 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;
         }
@@ -181,7 +259,11 @@ public final class TerminalPane implements AutoCloseable {
     }
 
     private void refresh() {
-        renderSnapshot.set(terminal.renderSnapshot());
+        // 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();
     }
 
     @Override
@@ -191,6 +273,7 @@ public final class TerminalPane implements AutoCloseable {
             session = null;
         }
         mouseEncoder.close();
+        renderState.close();
         terminal.close();
     }
 }

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

@@ -1,278 +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;
-    private int hiddenFloatingFocusIndex = -1;
-
-    public TerminalWorkspace(AppConfig config) {
-        this.config = config;
-        panes.add(openPane(false));
-    }
-
-    public TerminalPane activePane() {
-        return panes.get(activeIndex);
-    }
-
-    public List<TerminalPane> panes() {
-        List<TerminalPane> visible = panes.stream().filter(TerminalPane::visible).toList();
-        TerminalPane active = activePane();
-        if (!active.visible() || !active.floating()) {
-            return visible;
-        }
-
-        List<TerminalPane> ordered = new ArrayList<>(visible.size());
-        visible.stream()
-                .filter(pane -> pane != active)
-                .forEach(ordered::add);
-        ordered.add(active);
-        return List.copyOf(ordered);
-    }
-
-    public boolean isActive(TerminalPane pane) {
-        return activePane() == pane;
-    }
-
-    public void focus(TerminalPane pane) {
-        int index = panes.indexOf(pane);
-        if (index >= 0 && pane.visible()) {
-            activeIndex = index;
-        }
-    }
-
-    public void layout(double width, double height) {
-        List<TerminalPane> tiled = panes.stream()
-                .filter(TerminalPane::visible)
-                .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);
-        }
-
-        List<TerminalPane> floating = panes.stream()
-                .filter(TerminalPane::visible)
-                .filter(TerminalPane::floating)
-                .toList();
-        for (int i = 0; i < floating.size(); i++) {
-            TerminalPane pane = floating.get(i);
-            if (pane.visible() && pane.floating()) {
-                double floatingWidth = Math.max(420, width * 0.58);
-                double floatingHeight = Math.max(260, height * 0.58);
-                double offset = i * 28.0;
-                pane.bounds(
-                        Math.min(width - floatingWidth - 12.0, ((width - floatingWidth) / 2.0) + offset),
-                        Math.min(height - floatingHeight - 12.0, ((height - floatingHeight) / 2.0) + offset),
-                        floatingWidth,
-                        floatingHeight
-                );
-            }
-        }
-    }
-
-    public void navigate(Direction direction) {
-        TerminalPane current = activePane();
-        if (current.floating() && navigateFloatingStack(direction)) {
-            return;
-        }
-
-        panes.stream()
-                .filter(TerminalPane::visible)
-                .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() {
-        List<TerminalPane> floating = panes.stream()
-                .filter(TerminalPane::floating)
-                .toList();
-        if (floating.isEmpty()) {
-            createFloatingPane();
-            return;
-        }
-
-        boolean anyVisible = floating.stream().anyMatch(TerminalPane::visible);
-        if (anyVisible) {
-            TerminalPane active = activePane();
-            hiddenFloatingFocusIndex = active.floating() ? activeIndex : firstVisibleFloatingIndex();
-            floating.forEach(pane -> pane.setVisible(false));
-            activeIndex = firstVisibleNonFloatingIndex();
-        } else {
-            floating.forEach(pane -> pane.setVisible(true));
-            activeIndex = visibleIndexOrFallback(hiddenFloatingFocusIndex, panes.indexOf(floating.get(floating.size() - 1)));
-            hiddenFloatingFocusIndex = -1;
-        }
-    }
-
-    public void createFloatingPane() {
-        TerminalPane pane = openPane(true);
-        panes.add(pane);
-        activeIndex = panes.size() - 1;
-    }
-
-    public void nextFloatingPane() {
-        TerminalPane next = nextFloatingAfter(activeIndex);
-        next.setVisible(true);
-        activeIndex = panes.indexOf(next);
-    }
-
-    public void closeActivePane() {
-        TerminalPane active = activePane();
-        if (!active.floating() || panes.stream().filter(pane -> !pane.floating()).count() == 0) {
-            return;
-        }
-
-        int removed = activeIndex;
-        int previous = previousVisibleIndex(removed);
-        panes.remove(removed);
-        active.close();
-        activeIndex = adjustIndexAfterRemoval(previous, removed);
-        hiddenFloatingFocusIndex = adjustHiddenFocusAfterRemoval(hiddenFloatingFocusIndex, removed);
-    }
-
-    private TerminalPane nextFloatingAfter(int index) {
-        for (int i = index + 1; i < panes.size(); i++) {
-            TerminalPane pane = panes.get(i);
-            if (pane.floating()) {
-                return pane;
-            }
-        }
-        for (int i = 0; i <= index && i < panes.size(); i++) {
-            TerminalPane pane = panes.get(i);
-            if (pane.floating()) {
-                return pane;
-            }
-        }
-        return createAndReturnFloatingPane();
-    }
-
-    private TerminalPane createAndReturnFloatingPane() {
-        TerminalPane pane = openPane(true);
-        panes.add(pane);
-        return pane;
-    }
-
-    private boolean navigateFloatingStack(Direction direction) {
-        List<TerminalPane> floating = panes.stream()
-                .filter(TerminalPane::visible)
-                .filter(TerminalPane::floating)
-                .toList();
-        if (floating.size() < 2) {
-            return false;
-        }
-
-        int current = floating.indexOf(activePane());
-        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;
-        }
-
-        activeIndex = panes.indexOf(floating.get(next));
-        return true;
-    }
-
-    private int firstVisibleFloatingIndex() {
-        for (int i = 0; i < panes.size(); i++) {
-            TerminalPane pane = panes.get(i);
-            if (pane.visible() && pane.floating()) {
-                return i;
-            }
-        }
-        return -1;
-    }
-
-    private int firstVisibleNonFloatingIndex() {
-        for (int i = 0; i < panes.size(); i++) {
-            TerminalPane pane = panes.get(i);
-            if (pane.visible() && !pane.floating()) {
-                return i;
-            }
-        }
-        return 0;
-    }
-
-    private int previousVisibleIndex(int index) {
-        for (int i = index - 1; i >= 0; i--) {
-            if (panes.get(i).visible()) {
-                return i;
-            }
-        }
-        for (int i = index + 1; i < panes.size(); i++) {
-            if (panes.get(i).visible()) {
-                return i;
-            }
-        }
-        return firstVisibleNonFloatingIndex();
-    }
-
-    private int visibleIndexOrFallback(int index, int fallback) {
-        if (index >= 0 && index < panes.size() && panes.get(index).visible()) {
-            return index;
-        }
-        return fallback;
-    }
-
-    private static int adjustIndexAfterRemoval(int index, int removedIndex) {
-        if (index < 0) {
-            return 0;
-        }
-        return index > removedIndex ? index - 1 : index;
-    }
-
-    private static int adjustHiddenFocusAfterRemoval(int index, int removedIndex) {
-        if (index < 0 || index == removedIndex) {
-            return -1;
-        }
-        return index > removedIndex ? index - 1 : index;
-    }
-
-    private TerminalPane openPane(boolean floating) {
-        TerminalPane pane = TerminalPane.create(config.columns(), config.rows(), config.maxScrollback());
-        pane.setFloating(floating);
-        pane.attach(ShellSession.start(config.shell(), pane, config.columns(), config.rows()));
-        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();
-    }
-}