bump version

Fix double scroll issue.
Refine help text, keybindings, GUI themes, and undo system.
2025-12-01 16:38:10 -08:00 · 2025-12-01 16:37:51 -08:00 · 2025-12-01 15:21:52 -08:00 · 2025-12-01 12:00:52 -08:00 · 2025-12-01 12:00:10 -08:00 · 2025-12-01 11:59:51 -08:00
71 changed files with 4936 additions and 937 deletions
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -9,6 +9,9 @@ on:
 permissions:
  contents: write

+env:
+  BUILD_TYPE: Release
+
 jobs:
  homebrew:
    name: Bump Homebrew formula
@@ -34,4 +37,115 @@ jobs:
            
            Created by https://github.com/mislav/bump-homebrew-formula-action
        env:
-          COMMITTER_TOKEN: ${{ secrets.GH_CPAT }}
+          COMMITTER_TOKEN: ${{ secrets.GH_CPAT }}
+  linux-build:
+    name: Build Linux ${{ matrix.arch }}
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - arch: amd64
+            runner: ubuntu-latest
+          - arch: arm64
+            runner: ubuntu-24.04-arm64
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install deps
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y build-essential cmake pkg-config \
+            libncurses5-dev libncursesw5-dev \
+            libsdl2-dev libfreetype6-dev mesa-common-dev
+
+      - name: Configure (CMake, GUI ON)
+        run: |
+          cmake -S . -B build -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DBUILD_GUI=ON
+
+      - name: Build
+        run: |
+          cmake --build build --config ${BUILD_TYPE} -j
+
+      - name: Prepare dist
+        run: |
+          mkdir -p dist/linux-${{ matrix.arch }}
+          cp build/kte dist/linux-${{ matrix.arch }}/
+          cp build/kge dist/linux-${{ matrix.arch }}/
+          strip dist/linux-${{ matrix.arch }}/kte || true
+          strip dist/linux-${{ matrix.arch }}/kge || true
+
+      - name: Upload artifact (linux-${{ matrix.arch }})
+        uses: actions/upload-artifact@v4
+        with:
+          name: linux-${{ matrix.arch }}
+          path: dist/linux-${{ matrix.arch }}/*
+
+  macos-build:
+    name: Build macOS arm64 (.app)
+    runs-on: macos-14
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install deps (brew)
+        run: |
+          brew update
+          brew install cmake ncurses sdl2 freetype
+
+      - name: Configure (CMake, GUI ON, arm64)
+        run: |
+          cmake -S . -B build -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DBUILD_GUI=ON -DCMAKE_OSX_ARCHITECTURES=arm64
+
+      - name: Build
+        run: |
+          cmake --build build --config ${BUILD_TYPE} -j
+
+      - name: Zip kge.app
+        run: |
+          mkdir -p dist/macos-arm64
+          cd build
+          ditto -c -k --sequesterRsrc --keepParent kge.app ../dist/macos-arm64/kge.app.zip
+
+      - name: Upload artifact (macos-arm64)
+        uses: actions/upload-artifact@v4
+        with:
+          name: macos-arm64
+          path: dist/macos-arm64/kge.app.zip
+
+  release:
+    name: Create GitHub Release
+    needs: [ linux-build, macos-build ]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: dist
+
+      - name: Reshape artifact layout
+        run: |
+          ls -R dist
+          # Actions download-artifact places each named artifact in a subfolder
+          # Move into the expected dist structure for GoReleaser
+          mkdir -p dist/linux-amd64 dist/linux-arm64 dist/macos-arm64
+          if [ -d dist/linux-amd64/linux-amd64 ]; then mv dist/linux-amd64/linux-amd64/* dist/linux-amd64/; fi
+          if [ -d dist/linux-arm64/linux-arm64 ]; then mv dist/linux-arm64/linux-arm64/* dist/linux-arm64/; fi
+          if [ -d dist/macos-arm64/macos-arm64 ]; then mv dist/macos-arm64/macos-arm64/* dist/macos-arm64/; fi
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.22.x'
+
+      - name: Run GoReleaser
+        uses: goreleaser/goreleaser-action@v6
+        with:
+          version: latest
+          args: release --clean --config .goreleaser.yaml
+        env:
+          GITHUB_TOKEN: ${{ secrets.GH_CPAT }}
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,5 @@
 !.idea
 cmake-build*
 build
+/imgui.ini
+result
--- a/.goreleaser.yaml
+++ b/.goreleaser.yaml
@@ -0,0 +1,69 @@
+# GoReleaser configuration for kte/kge (C++ project)
+# We use GoReleaser only for releasing: changelog, checksums, and uploading
+# prebuilt artifacts that are produced by the CI workflow.
+
+version: 2
+
+project_name: kte
+
+before:
+  hooks:
+    # No build here; artifacts are produced by the CI jobs and placed into dist/
+    - echo "GoReleaser: using prebuilt artifacts from dist/"
+
+builds:
+  # No Go builds; this is a C++ project.
+  - id: noop
+    skip: true
+
+checksum:
+  name_template: "checksums.txt"
+  algorithm: sha256
+
+release:
+  # Rely on GITHUB_TOKEN from the workflow.
+  draft: false
+  prerelease: auto
+  mode: replace
+  footer: |
+    Built with CMake. See README for platform dependencies.
+  extra_files:
+    # Linux binaries (amd64, arm64)
+    - glob: dist/linux-amd64/kte
+    - glob: dist/linux-amd64/kge
+    - glob: dist/linux-arm64/kte
+    - glob: dist/linux-arm64/kge
+    # macOS Apple Silicon app bundle (zipped)
+    - glob: dist/macos-arm64/kge.app.zip
+
+changelog:
+  sort: asc
+  use: github
+  filters:
+    exclude:
+      - '^docs: '
+      - '^chore: '
+      - '^ci: '
+
+announce:
+  skip: true
+
+signs:
+  # No signing by default.
+  - artifacts: none
+
+archives:
+  # We are uploading raw binaries / zip created by CI, so no archives here.
+  - id: none
+    formats: [binary]
+    builds: [noop]
+
+blobs: []
+
+brews: []
+
+snapcrafts: []
+
+nfpm: []
+
+publishers: []
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -7,6 +7,7 @@
    <option name="/Default/Environment/Hierarchy/GeneratedFilesCacheKey/Timestamp/@EntryValue" value="3" type="long" />
    <option name="/Default/Housekeeping/FeatureSuggestion/FeatureSuggestionManager/DisabledSuggesters/=SwitchToGoToActionSuggester/@EntryIndexedValue" value="true" type="bool" />
    <option name="/Default/Housekeeping/GlobalSettingsUpgraded/IsUpgraded/@EntryValue" value="true" type="bool" />
+    <option name="/Default/Housekeeping/LiveTemplatesHousekeeping/HotspotSessionHintIsShown/@EntryValue" value="true" type="bool" />
    <option name="/Default/Housekeeping/OptionsDialog/SelectedPageId/@EntryValue" value="CppFormatterOtherPage" type="string" />
    <option name="/Default/Housekeeping/RefactoringsMru/RenameRefactoring/DoSearchForTextInStrings/@EntryValue" value="true" type="bool" />
    <option name="/Default/RiderDebugger/RiderRestoreDecompile/RestoreDecompileSetting/@EntryValue" value="false" type="bool" />
@@ -33,12 +34,30 @@
    </configurations>
  </component>
  <component name="ChangeListManager">
-    <list default="true" id="e1fe3ab0-3650-4fca-8664-a247d5dfa457" name="Changes" comment="Refactor code for consistency and enhanced functionality.&#10;&#10;- Normalize path handling for buffer operations, supporting tilde expansion and absolute paths.&#10;- Introduce `DisplayNameFor` to uniquely resolve buffer display names, minimizing filename clashes.&#10;- Add new commands: `ShowWorkingDirectory` and `ChangeWorkingDirectory`.&#10;- Refine keybindings and enhance existing commands for improved command flow.&#10;- Adjust GUI and terminal renderers to display total line counts alongside filenames.&#10;- Update coding style to align with project guidelines.">
+    <list default="true" id="e1fe3ab0-3650-4fca-8664-a247d5dfa457" name="Changes" comment="Add Nord theme for real">
      <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
      <change beforePath="$PROJECT_DIR$/Buffer.cc" beforeDir="false" afterPath="$PROJECT_DIR$/Buffer.cc" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/Buffer.h" beforeDir="false" afterPath="$PROJECT_DIR$/Buffer.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/CMakeLists.txt" beforeDir="false" afterPath="$PROJECT_DIR$/CMakeLists.txt" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/Command.cc" beforeDir="false" afterPath="$PROJECT_DIR$/Command.cc" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/Command.h" beforeDir="false" afterPath="$PROJECT_DIR$/Command.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/Editor.h" beforeDir="false" afterPath="$PROJECT_DIR$/Editor.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/GUIConfig.cc" beforeDir="false" afterPath="$PROJECT_DIR$/GUIConfig.cc" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/GUIConfig.h" beforeDir="false" afterPath="$PROJECT_DIR$/GUIConfig.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/GUIFrontend.cc" beforeDir="false" afterPath="$PROJECT_DIR$/GUIFrontend.cc" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/GUIFrontend.h" beforeDir="false" afterPath="$PROJECT_DIR$/GUIFrontend.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/GUIInputHandler.cc" beforeDir="false" afterPath="$PROJECT_DIR$/GUIInputHandler.cc" afterDir="false" />
      <change beforePath="$PROJECT_DIR$/GUIRenderer.cc" beforeDir="false" afterPath="$PROJECT_DIR$/GUIRenderer.cc" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/GUITheme.h" beforeDir="false" afterPath="$PROJECT_DIR$/GUITheme.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/HelpText.cc" beforeDir="false" afterPath="$PROJECT_DIR$/HelpText.cc" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/HelpText.h" beforeDir="false" afterPath="$PROJECT_DIR$/HelpText.h" afterDir="false" />
      <change beforePath="$PROJECT_DIR$/KKeymap.cc" beforeDir="false" afterPath="$PROJECT_DIR$/KKeymap.cc" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/main.cc" beforeDir="false" afterPath="$PROJECT_DIR$/main.cc" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/TerminalRenderer.cc" beforeDir="false" afterPath="$PROJECT_DIR$/TerminalRenderer.cc" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/UndoSystem.cc" beforeDir="false" afterPath="$PROJECT_DIR$/UndoSystem.cc" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/UndoSystem.h" beforeDir="false" afterPath="$PROJECT_DIR$/UndoSystem.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/docs/kge.1" beforeDir="false" afterPath="$PROJECT_DIR$/docs/kge.1" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/docs/kte.1" beforeDir="false" afterPath="$PROJECT_DIR$/docs/kte.1" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/test_undo.cc" beforeDir="false" afterPath="$PROJECT_DIR$/test_undo.cc" afterDir="false" />
    </list>
    <option name="SHOW_DIALOG" value="false" />
    <option name="HIGHLIGHT_CONFLICTS" value="true" />
@@ -53,25 +72,28 @@
    <option name="myRunOnSave" value="true" />
  </component>
  <component name="Git.Settings">
+    <option name="PUSH_TAGS">
+      <GitPushTagMode>
+        <option name="argument" value="--tags" />
+        <option name="title" value="All" />
+      </GitPushTagMode>
+    </option>
    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
    <option name="UPDATE_TYPE" value="REBASE" />
  </component>
  <component name="HighlightingSettingsPerFile">
+    <setting file="mock:///AIAssistantSnippet." root0="SKIP_HIGHLIGHTING" />
+    <setting file="mock:///AIAssistantSnippet.." root0="SKIP_HIGHLIGHTING" />
    <setting file="mock:///AIAssistantSnippet.." root0="SKIP_HIGHLIGHTING" />
    <setting file="mock:///AIAssistantSnippet.." root0="SKIP_HIGHLIGHTING" />
    <setting file="mock:///AIAssistantSnippet.." root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
-    <setting file="mock:///dummy.cpp" root0="SKIP_HIGHLIGHTING" />
  </component>
  <component name="OptimizeOnSaveOptions">
    <option name="myRunOnSave" value="true" />
  </component>
+  <component name="ProblemsViewState">
+    <option name="selectedTabId" value="CurrentFile" />
+  </component>
  <component name="ProjectApplicationVersion">
    <option name="ide" value="CLion" />
    <option name="majorVersion" value="2025" />
@@ -91,55 +113,60 @@
    <option name="sortByType" value="true" />
    <option name="sortKey" value="BY_TYPE" />
  </component>
-  <component name="PropertiesComponent">{
-  &quot;keyToString&quot;: {
-    &quot;CMake Application.kge.executor&quot;: &quot;Run&quot;,
-    &quot;CMake Application.test_example.executor&quot;: &quot;Run&quot;,
-    &quot;CMake Application.test_undo.executor&quot;: &quot;Run&quot;,
-    &quot;ModuleVcsDetector.initialDetectionPerformed&quot;: &quot;true&quot;,
-    &quot;NIXITCH_NIXPKGS_CONFIG&quot;: &quot;&quot;,
-    &quot;NIXITCH_NIX_CONF_DIR&quot;: &quot;&quot;,
-    &quot;NIXITCH_NIX_OTHER_STORES&quot;: &quot;&quot;,
-    &quot;NIXITCH_NIX_PATH&quot;: &quot;&quot;,
-    &quot;NIXITCH_NIX_PROFILES&quot;: &quot;&quot;,
-    &quot;NIXITCH_NIX_REMOTE&quot;: &quot;&quot;,
-    &quot;NIXITCH_NIX_USER_PROFILE_DIR&quot;: &quot;&quot;,
-    &quot;RunOnceActivity.RadMigrateCodeStyle&quot;: &quot;true&quot;,
-    &quot;RunOnceActivity.ShowReadmeOnStart&quot;: &quot;true&quot;,
-    &quot;RunOnceActivity.cidr.known.project.marker&quot;: &quot;true&quot;,
-    &quot;RunOnceActivity.git.unshallow&quot;: &quot;true&quot;,
-    &quot;RunOnceActivity.readMode.enableVisualFormatting&quot;: &quot;true&quot;,
-    &quot;RunOnceActivity.west.config.association.type.startup.service&quot;: &quot;true&quot;,
-    &quot;cf.first.check.clang-format&quot;: &quot;false&quot;,
-    &quot;cidr.known.project.marker&quot;: &quot;true&quot;,
-    &quot;code.cleanup.on.save&quot;: &quot;true&quot;,
-    &quot;com.intellij.ml.llm.matterhorn.ej.ui.settings.DefaultModelSelectionForGA.v1&quot;: &quot;true&quot;,
-    &quot;git-widget-placeholder&quot;: &quot;master&quot;,
-    &quot;junie.onboarding.icon.badge.shown&quot;: &quot;true&quot;,
-    &quot;node.js.detected.package.eslint&quot;: &quot;true&quot;,
-    &quot;node.js.detected.package.tslint&quot;: &quot;true&quot;,
-    &quot;node.js.selected.package.eslint&quot;: &quot;(autodetect)&quot;,
-    &quot;node.js.selected.package.tslint&quot;: &quot;(autodetect)&quot;,
-    &quot;nodejs_package_manager_path&quot;: &quot;npm&quot;,
-    &quot;onboarding.tips.debug.path&quot;: &quot;/Users/kyle/src/kte/main.cpp&quot;,
-    &quot;rearrange.code.on.save&quot;: &quot;true&quot;,
-    &quot;settings.editor.selected.configurable&quot;: &quot;editor.preferences.fonts.default&quot;,
-    &quot;to.speed.mode.migration.done&quot;: &quot;true&quot;,
-    &quot;vue.rearranger.settings.migration&quot;: &quot;true&quot;
+  <component name="PropertiesComponent"><![CDATA[{
+  "keyToString": {
+    "CMake Application.kge.executor": "Run",
+    "CMake Application.test_example.executor": "Run",
+    "CMake Application.test_undo.executor": "Run",
+    "ModuleVcsDetector.initialDetectionPerformed": "true",
+    "NIXITCH_NIXPKGS_CONFIG": "",
+    "NIXITCH_NIX_CONF_DIR": "",
+    "NIXITCH_NIX_OTHER_STORES": "",
+    "NIXITCH_NIX_PATH": "",
+    "NIXITCH_NIX_PROFILES": "",
+    "NIXITCH_NIX_REMOTE": "",
+    "NIXITCH_NIX_USER_PROFILE_DIR": "",
+    "RunOnceActivity.RadMigrateCodeStyle": "true",
+    "RunOnceActivity.ShowReadmeOnStart": "true",
+    "RunOnceActivity.cidr.known.project.marker": "true",
+    "RunOnceActivity.git.unshallow": "true",
+    "RunOnceActivity.readMode.enableVisualFormatting": "true",
+    "RunOnceActivity.west.config.association.type.startup.service": "true",
+    "cf.first.check.clang-format": "false",
+    "cidr.known.project.marker": "true",
+    "code.cleanup.on.save": "true",
+    "com.intellij.ml.llm.matterhorn.ej.ui.settings.DefaultModelSelectionForGA.v1": "true",
+    "git-widget-placeholder": "master",
+    "junie.onboarding.icon.badge.shown": "true",
+    "node.js.detected.package.eslint": "true",
+    "node.js.detected.package.tslint": "true",
+    "node.js.selected.package.eslint": "(autodetect)",
+    "node.js.selected.package.tslint": "(autodetect)",
+    "nodejs_package_manager_path": "npm",
+    "onboarding.tips.debug.path": "/Users/kyle/src/kte/main.cpp",
+    "rearrange.code.on.save": "true",
+    "settings.editor.selected.configurable": "CMakeSettings",
+    "to.speed.mode.migration.done": "true",
+    "vue.rearranger.settings.migration": "true"
  }
-}</component>
+}]]></component>
  <component name="RecentsManager">
    <key name="MoveFile.RECENT_KEYS">
      <recent name="$PROJECT_DIR$/docs" />
    </key>
  </component>
  <component name="RunManager" selected="CMake Application.kge">
+    <configuration default="true" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" EMULATE_TERMINAL="false" PASS_PARENT_ENVS_2="true">
+      <method v="2">
+        <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
+      </method>
+    </configuration>
    <configuration name="imgui" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" EMULATE_TERMINAL="false" PASS_PARENT_ENVS_2="true" PROJECT_NAME="kte" TARGET_NAME="imgui" CONFIG_NAME="Debug">
      <method v="2">
        <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
      </method>
    </configuration>
-    <configuration name="kge" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" EMULATE_TERMINAL="false" WORKING_DIR="file://$PROJECT_DIR$" PASS_PARENT_ENVS_2="true" PROJECT_NAME="kte" TARGET_NAME="kge" CONFIG_NAME="Debug" RUN_TARGET_PROJECT_NAME="kte" RUN_TARGET_NAME="kge">
+    <configuration name="kge" type="CMakeRunConfiguration" factoryName="Application" PROGRAM_PARAMS="$PROJECT_DIR$/cmake-build-debug/test.txt" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" EMULATE_TERMINAL="false" WORKING_DIR="file://$PROJECT_DIR$" PASS_PARENT_ENVS_2="true" PROJECT_NAME="kte" TARGET_NAME="kge" CONFIG_NAME="Debug" RUN_TARGET_PROJECT_NAME="kte" RUN_TARGET_NAME="kge">
      <method v="2">
        <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
      </method>
@@ -170,7 +197,7 @@
      <workItem from="1764539556448" duration="156000" />
      <workItem from="1764539725338" duration="1075000" />
      <workItem from="1764542392763" duration="3512000" />
-      <workItem from="1764548345516" duration="3453000" />
+      <workItem from="1764548345516" duration="50201000" />
    </task>
    <task id="LOCAL-00001" summary="Add undo/redo infrastructure and buffer management additions.">
      <option name="closed" value="true" />
@@ -252,7 +279,79 @@
      <option name="project" value="LOCAL" />
      <updated>1764550164829</updated>
    </task>
-    <option name="localTasksCounter" value="11" />
+    <task id="LOCAL-00011" summary="Add horizontal scrolling support and refactor mouse click handling in GUI.&#10;&#10;- Introduce horizontal scrolling with column offset synchronization in GUI.&#10;- Refactor mouse click handling for improved accuracy and viewport alignment.&#10;- Enhance tab expansion and cursor rendering logic for better user experience.&#10;- Replace redundant variable declarations in `Buffer` for cleaner code.">
+      <option name="closed" value="true" />
+      <created>1764551986561</created>
+      <option name="number" value="00011" />
+      <option name="presentableId" value="LOCAL-00011" />
+      <option name="project" value="LOCAL" />
+      <updated>1764551986561</updated>
+    </task>
+    <task id="LOCAL-00012" summary="Introduce file picker and GUI configuration with enhancements.&#10;&#10;- Add visual file picker for GUI with toggle support.&#10;- Introduce `GUIConfig` class for loading GUI settings from configuration file.&#10;- Refactor window initialization to support dynamic sizing based on configuration.&#10;- Add macOS-specific handling for fullscreen behavior.&#10;- Improve header inclusion order and minor code cleanup.">
+      <option name="closed" value="true" />
+      <created>1764556512864</created>
+      <option name="number" value="00012" />
+      <option name="presentableId" value="LOCAL-00012" />
+      <option name="project" value="LOCAL" />
+      <updated>1764556512864</updated>
+    </task>
+    <task id="LOCAL-00013" summary="Add buffer position display and documentation improvements.&#10;&#10;- Display buffer position prefix &quot;[x/N]&quot; in GUI and terminal renderers.&#10;- Improve `kte` and `kge` man pages with frontend usage details and project homepage.&#10;- Update README with GUI invocation instructions.&#10;- Bump version to 1.0.0.">
+      <option name="closed" value="true" />
+      <created>1764556854788</created>
+      <option name="number" value="00013" />
+      <option name="presentableId" value="LOCAL-00013" />
+      <option name="project" value="LOCAL" />
+      <updated>1764556854788</updated>
+    </task>
+    <task id="LOCAL-00014" summary="Actually add the screenshot.">
+      <option name="closed" value="true" />
+      <created>1764557759844</created>
+      <option name="number" value="00014" />
+      <option name="presentableId" value="LOCAL-00014" />
+      <option name="project" value="LOCAL" />
+      <updated>1764557759844</updated>
+    </task>
+    <task id="LOCAL-00015" summary="Fix void crash in kge.">
+      <option name="closed" value="true" />
+      <created>1764568264996</created>
+      <option name="number" value="00015" />
+      <option name="presentableId" value="LOCAL-00015" />
+      <option name="project" value="LOCAL" />
+      <updated>1764568264996</updated>
+    </task>
+    <task id="LOCAL-00016" summary="add regex and search/replace functionality to editor">
+      <option name="closed" value="true" />
+      <created>1764574397967</created>
+      <option name="number" value="00016" />
+      <option name="presentableId" value="LOCAL-00016" />
+      <option name="project" value="LOCAL" />
+      <updated>1764574397967</updated>
+    </task>
+    <task id="LOCAL-00017" summary="Add regex search, search/replace, and buffer read-only mode functionality with help text">
+      <option name="closed" value="true" />
+      <created>1764586480092</created>
+      <option name="number" value="00017" />
+      <option name="presentableId" value="LOCAL-00017" />
+      <option name="project" value="LOCAL" />
+      <updated>1764586480092</updated>
+    </task>
+    <task id="LOCAL-00018" summary="Nord theme and undo system refinements&#10;&#10;- Improve text input/event batching&#10;- Enhance debugging with optional instrumentation&#10;- Begin implementation of non-linear undo tree structure.">
+      <option name="closed" value="true" />
+      <created>1764619193516</created>
+      <option name="number" value="00018" />
+      <option name="presentableId" value="LOCAL-00018" />
+      <option name="project" value="LOCAL" />
+      <updated>1764619193517</updated>
+    </task>
+    <task id="LOCAL-00019" summary="Add Nord theme for real">
+      <option name="closed" value="true" />
+      <created>1764619210817</created>
+      <option name="number" value="00019" />
+      <option name="presentableId" value="LOCAL-00019" />
+      <option name="project" value="LOCAL" />
+      <updated>1764619210817</updated>
+    </task>
+    <option name="localTasksCounter" value="20" />
    <servers />
  </component>
  <component name="TypeScriptGeneratedFilesManager">
@@ -276,7 +375,16 @@
    <MESSAGE value="Add man pages for `kge` and `kte` with installation targets in CMake.&#10;&#10;- Introduce `docs/kge.1` and `docs/kte.1` man pages covering usage, options, keybindings, and examples.&#10;- Update `CMakeLists.txt` to install man pages under `${CMAKE_INSTALL_MANDIR}/man1`.&#10;- Ensure `kge` man page installation is conditional on GUI being built." />
    <MESSAGE value="Add GUI initialization updates and improve navigation commands.&#10;&#10;- Implement terminal detachment for GUI mode to enable terminal closure post-launch.&#10;- Add `+N` support for opening files at specific line numbers and refine cursor positioning.&#10;- Introduce `JumpToLine` command for direct navigation by line number.&#10;- Enhance mouse wheel handling for line-wise scrolling." />
    <MESSAGE value="Refactor code for consistency and enhanced functionality.&#10;&#10;- Normalize path handling for buffer operations, supporting tilde expansion and absolute paths.&#10;- Introduce `DisplayNameFor` to uniquely resolve buffer display names, minimizing filename clashes.&#10;- Add new commands: `ShowWorkingDirectory` and `ChangeWorkingDirectory`.&#10;- Refine keybindings and enhance existing commands for improved command flow.&#10;- Adjust GUI and terminal renderers to display total line counts alongside filenames.&#10;- Update coding style to align with project guidelines." />
-    <option name="LAST_COMMIT_MESSAGE" value="Refactor code for consistency and enhanced functionality.&#10;&#10;- Normalize path handling for buffer operations, supporting tilde expansion and absolute paths.&#10;- Introduce `DisplayNameFor` to uniquely resolve buffer display names, minimizing filename clashes.&#10;- Add new commands: `ShowWorkingDirectory` and `ChangeWorkingDirectory`.&#10;- Refine keybindings and enhance existing commands for improved command flow.&#10;- Adjust GUI and terminal renderers to display total line counts alongside filenames.&#10;- Update coding style to align with project guidelines." />
+    <MESSAGE value="Add horizontal scrolling support and refactor mouse click handling in GUI.&#10;&#10;- Introduce horizontal scrolling with column offset synchronization in GUI.&#10;- Refactor mouse click handling for improved accuracy and viewport alignment.&#10;- Enhance tab expansion and cursor rendering logic for better user experience.&#10;- Replace redundant variable declarations in `Buffer` for cleaner code." />
+    <MESSAGE value="Introduce file picker and GUI configuration with enhancements.&#10;&#10;- Add visual file picker for GUI with toggle support.&#10;- Introduce `GUIConfig` class for loading GUI settings from configuration file.&#10;- Refactor window initialization to support dynamic sizing based on configuration.&#10;- Add macOS-specific handling for fullscreen behavior.&#10;- Improve header inclusion order and minor code cleanup." />
+    <MESSAGE value="Add buffer position display and documentation improvements.&#10;&#10;- Display buffer position prefix &quot;[x/N]&quot; in GUI and terminal renderers.&#10;- Improve `kte` and `kge` man pages with frontend usage details and project homepage.&#10;- Update README with GUI invocation instructions.&#10;- Bump version to 1.0.0." />
+    <MESSAGE value="Actually add the screenshot." />
+    <MESSAGE value="Fix void crash in kge." />
+    <MESSAGE value="add regex and search/replace functionality to editor" />
+    <MESSAGE value="Add regex search, search/replace, and buffer read-only mode functionality with help text" />
+    <MESSAGE value="Nord theme and undo system refinements&#10;&#10;- Improve text input/event batching&#10;- Enhance debugging with optional instrumentation&#10;- Begin implementation of non-linear undo tree structure." />
+    <MESSAGE value="Add Nord theme for real" />
+    <option name="LAST_COMMIT_MESSAGE" value="Add Nord theme for real" />
  </component>
  <component name="XSLT-Support.FileAssociations.UIState">
    <expand />
--- a/Buffer.cc
+++ b/Buffer.cc
@@ -1,12 +1,12 @@
-#include "Buffer.h"
-#include "UndoSystem.h"
-#include "UndoTree.h"
-
 #include <fstream>
 #include <sstream>
 #include <filesystem>
 #include <cstdlib>

+#include "Buffer.h"
+#include "UndoSystem.h"
+#include "UndoTree.h"
+

 Buffer::Buffer()
 {
@@ -36,6 +36,7 @@ Buffer::Buffer(const Buffer &other)
 	filename_       = other.filename_;
 	is_file_backed_ = other.is_file_backed_;
 	dirty_          = other.dirty_;
+	read_only_      = other.read_only_;
 	mark_set_       = other.mark_set_;
 	mark_curx_      = other.mark_curx_;
 	mark_cury_      = other.mark_cury_;
@@ -60,6 +61,7 @@ Buffer::operator=(const Buffer &other)
 	filename_       = other.filename_;
 	is_file_backed_ = other.is_file_backed_;
 	dirty_          = other.dirty_;
+	read_only_      = other.read_only_;
 	mark_set_       = other.mark_set_;
 	mark_curx_      = other.mark_curx_;
 	mark_cury_      = other.mark_cury_;
@@ -82,6 +84,7 @@ Buffer::Buffer(Buffer &&other) noexcept
 	  filename_(std::move(other.filename_)),
 	  is_file_backed_(other.is_file_backed_),
 	  dirty_(other.dirty_),
+	  read_only_(other.read_only_),
 	  mark_set_(other.mark_set_),
 	  mark_curx_(other.mark_curx_),
 	  mark_cury_(other.mark_cury_),
@@ -112,6 +115,7 @@ Buffer::operator=(Buffer &&other) noexcept
 	filename_       = std::move(other.filename_);
 	is_file_backed_ = other.is_file_backed_;
 	dirty_          = other.dirty_;
+	read_only_      = other.read_only_;
 	mark_set_       = other.mark_set_;
 	mark_curx_      = other.mark_curx_;
 	mark_cury_      = other.mark_cury_;
@@ -366,7 +370,7 @@ Buffer::insert_text(int row, int col, std::string_view text)
 		// Split line at x
 		std::string tail = rows_[y].substr(x);
 		rows_[y].erase(x);
-		rows_.insert(rows_.begin() + static_cast<std::ptrdiff_t>(y + 1), tail);
+		rows_.insert(rows_.begin() + static_cast<std::ptrdiff_t>(y + 1), Line(tail));
 		y += 1;
 		x = 0;
 		remain.erase(0, pos + 1);
@@ -427,7 +431,7 @@ Buffer::split_line(int row, const int col)
 	const auto x    = std::min<std::size_t>(static_cast<std::size_t>(col), rows_[y].size());
 	const auto tail = rows_[y].substr(x);
 	rows_[y].erase(x);
-	rows_.insert(rows_.begin() + static_cast<std::ptrdiff_t>(y + 1), tail);
+	rows_.insert(rows_.begin() + static_cast<std::ptrdiff_t>(y + 1), Line(tail));
 }


@@ -455,7 +459,7 @@ Buffer::insert_row(int row, const std::string_view text)
 		row = 0;
 	if (static_cast<std::size_t>(row) > rows_.size())
 		row = static_cast<int>(rows_.size());
-	rows_.insert(rows_.begin() + row, std::string(text));
+	rows_.insert(rows_.begin() + row, Line(std::string(text)));
 }


--- a/Buffer.h
+++ b/Buffer.h
@@ -5,6 +5,7 @@
 #define KTE_BUFFER_H

 #include <cstddef>
+#include <memory>
 #include <string>
 #include <vector>
 #include <string_view>
@@ -12,6 +13,7 @@
 #include "AppendBuffer.h"
 #include "UndoSystem.h"

+
 class Buffer {
 public:
 	Buffer();
@@ -75,13 +77,13 @@ public:
 		Line() = default;


-		Line(const char *s)
+		explicit Line(const char *s)
 		{
 			assign_from(s ? std::string(s) : std::string());
 		}


-		Line(const std::string &s)
+		explicit Line(const std::string &s)
 		{
 			assign_from(s);
 		}
@@ -137,29 +139,38 @@ public:


 		// conversions
-		operator std::string() const
+		explicit operator std::string() const
 		{
-			return std::string(buf_.Data() ? buf_.Data() : "", buf_.Size());
+			return {buf_.Data() ? buf_.Data() : "", buf_.Size()};
 		}


 		// string-like API used by command/renderer layers (implemented via materialization for now)
-		std::string substr(std::size_t pos) const
+		[[nodiscard]] std::string substr(std::size_t pos) const
 		{
 			const std::size_t n = buf_.Size();
 			if (pos >= n)
-				return std::string();
-			return std::string(buf_.Data() + pos, n - pos);
+				return {};
+			return {buf_.Data() + pos, n - pos};
 		}


-		std::string substr(std::size_t pos, std::size_t len) const
+		[[nodiscard]] std::string substr(std::size_t pos, std::size_t len) const
 		{
 			const std::size_t n = buf_.Size();
 			if (pos >= n)
-				return std::string();
+				return {};
 			const std::size_t take = (pos + len > n) ? (n - pos) : len;
-			return std::string(buf_.Data() + pos, take);
+			return {buf_.Data() + pos, take};
+		}
+
+
+		// minimal find() to support search within a line
+		[[nodiscard]] std::size_t find(const std::string &needle, const std::size_t pos = 0) const
+		{
+			// Materialize to std::string for now; Line is backed by AppendBuffer
+			const auto s = static_cast<std::string>(*this);
+			return s.find(needle, pos);
 		}


@@ -252,6 +263,15 @@ public:
 	}


+	// Set a virtual (non file-backed) display name for this buffer, e.g. "+HELP+"
+	// This does not mark the buffer as file-backed.
+	void SetVirtualName(const std::string &name)
+	{
+		filename_       = name;
+		is_file_backed_ = false;
+	}
+
+
 	[[nodiscard]] bool IsFileBacked() const
 	{
 		return is_file_backed_;
@@ -264,20 +284,39 @@ public:
 	}


-	void SetCursor(std::size_t x, std::size_t y)
+	// Read-only flag
+	[[nodiscard]] bool IsReadOnly() const
+	{
+		return read_only_;
+	}
+
+
+	void SetReadOnly(bool ro)
+	{
+		read_only_ = ro;
+	}
+
+
+	void ToggleReadOnly()
+	{
+		read_only_ = !read_only_;
+	}
+
+
+	void SetCursor(const std::size_t x, const std::size_t y)
 	{
 		curx_ = x;
 		cury_ = y;
 	}


-	void SetRenderX(std::size_t rx)
+	void SetRenderX(const std::size_t rx)
 	{
 		rx_ = rx;
 	}


-	void SetOffsets(std::size_t row, std::size_t col)
+	void SetOffsets(const std::size_t row, const std::size_t col)
 	{
 		rowoffs_ = row;
 		coloffs_ = col;
@@ -297,7 +336,7 @@ public:
 	}


-	void SetMark(std::size_t x, std::size_t y)
+	void SetMark(const std::size_t x, const std::size_t y)
 	{
 		mark_set_  = true;
 		mark_curx_ = x;
@@ -342,7 +381,7 @@ public:
 	// Undo system accessors (created per-buffer)
 	UndoSystem *Undo();

-	const UndoSystem *Undo() const;
+	[[nodiscard]] const UndoSystem *Undo() const;

 private:
 	// State mirroring original C struct (without undo_tree)
@@ -354,6 +393,7 @@ private:
 	std::string filename_;
 	bool is_file_backed_   = false;
 	bool dirty_            = false;
+	bool read_only_        = false;
 	bool mark_set_         = false;
 	std::size_t mark_curx_ = 0, mark_cury_ = 0;

--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,14 +4,15 @@ project(kte)
 include(GNUInstallDirs)

 set(CMAKE_CXX_STANDARD 17)
-set(KTE_VERSION "0.9.2")
+set(KTE_VERSION "1.1.2")

 # Default to terminal-only build to avoid SDL/OpenGL dependency by default.
 # Enable with -DBUILD_GUI=ON when SDL2/OpenGL/Freetype are available.
-set(BUILD_GUI OFF CACHE BOOL "Enable building the graphical version.")
+set(BUILD_GUI ON CACHE BOOL "Enable building the graphical version.")
 set(BUILD_TESTS OFF CACHE BOOL "Enable building test programs.")
 option(KTE_USE_PIECE_TABLE "Use PieceTable instead of GapBuffer implementation" ON)
 set(KTE_FONT_SIZE "18.0" CACHE STRING "Default font size for GUI")
+option(KTE_UNDO_DEBUG "Enable undo instrumentation logs" OFF)

 if (CMAKE_HOST_UNIX)
    message(STATUS "Build system is POSIX.")
@@ -55,6 +56,7 @@ set(COMMON_SOURCES
        Buffer.cc
        Editor.cc
        Command.cc
+        HelpText.cc
        KKeymap.cc
        TerminalInputHandler.cc
        TerminalRenderer.cc
@@ -74,6 +76,7 @@ set(COMMON_HEADERS
        Editor.h
        AppendBuffer.h
        Command.h
+        HelpText.h
        KKeymap.h
        InputHandler.h
        TerminalInputHandler.h
@@ -99,6 +102,9 @@ add_executable(kte
 if (KTE_USE_PIECE_TABLE)
    target_compile_definitions(kte PRIVATE KTE_USE_PIECE_TABLE=1)
 endif ()
+if (KTE_UNDO_DEBUG)
+    target_compile_definitions(kte PRIVATE KTE_UNDO_DEBUG=1)
+endif ()

 target_link_libraries(kte ${CURSES_LIBRARIES})

@@ -121,6 +127,10 @@ if (BUILD_TESTS)
        target_compile_definitions(test_undo PRIVATE KTE_USE_PIECE_TABLE=1)
    endif ()

+    if (KTE_UNDO_DEBUG)
+        target_compile_definitions(test_undo PRIVATE KTE_UNDO_DEBUG=1)
+    endif ()
+

    target_link_libraries(test_undo ${CURSES_LIBRARIES})
 endif ()
@@ -128,6 +138,8 @@ endif ()
 if (${BUILD_GUI})
    target_sources(kte PRIVATE
            Font.h
+            GUIConfig.cc
+            GUIConfig.h
            GUIRenderer.cc
            GUIRenderer.h
            GUIInputHandler.cc
@@ -142,6 +154,8 @@ if (${BUILD_GUI})
            main.cc
            ${COMMON_SOURCES}
            ${COMMON_HEADERS}
+            GUIConfig.cc
+            GUIConfig.h
            GUIRenderer.cc
            GUIRenderer.h
            GUIInputHandler.cc
@@ -149,10 +163,22 @@ if (${BUILD_GUI})
            GUIFrontend.cc
            GUIFrontend.h)
    target_compile_definitions(kge PRIVATE KTE_BUILD_GUI=1 KTE_DEFAULT_GUI=1 KTE_FONT_SIZE=${KTE_FONT_SIZE})
+    if (KTE_UNDO_DEBUG)
+        target_compile_definitions(kge PRIVATE KTE_UNDO_DEBUG=1)
+    endif ()
    target_link_libraries(kge ${CURSES_LIBRARIES} imgui)

    # On macOS, build kge as a proper .app bundle
    if (APPLE)
+        # Define the icon file
+        set(MACOSX_BUNDLE_ICON_FILE kge.icns)
+        set(kge_ICON "${CMAKE_CURRENT_SOURCE_DIR}/${MACOSX_BUNDLE_ICON_FILE}")
+
+        # Add icon to the target sources and mark it as a resource
+        target_sources(kge PRIVATE ${kge_ICON})
+        set_source_files_properties(${kge_ICON} PROPERTIES
+                MACOSX_PACKAGE_LOCATION Resources)
+
        # Configure Info.plist with version and identifiers
        set(KGE_BUNDLE_ID "dev.wntrmute.kge")
        configure_file(
@@ -164,11 +190,23 @@ if (${BUILD_GUI})
                MACOSX_BUNDLE TRUE
                MACOSX_BUNDLE_GUI_IDENTIFIER ${KGE_BUNDLE_ID}
                MACOSX_BUNDLE_BUNDLE_NAME "kge"
+                MACOSX_BUNDLE_ICON_FILE ${MACOSX_BUNDLE_ICON_FILE}
                MACOSX_BUNDLE_INFO_PLIST "${CMAKE_CURRENT_BINARY_DIR}/kge-Info.plist")

+        add_dependencies(kge kte)
+        add_custom_command(TARGET kge POST_BUILD
+                COMMAND ${CMAKE_COMMAND} -E copy
+                $<TARGET_FILE:kte>
+                $<TARGET_FILE_DIR:kge>/kte
+                COMMENT "Copying kte binary into kge.app bundle")
+
        install(TARGETS kge
                BUNDLE DESTINATION .
        )
+
+        install(TARGETS kte
+                RUNTIME DESTINATION kge.app/Contents/MacOS
+        )
    else ()
        install(TARGETS kge
                RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
@@ -176,4 +214,5 @@ if (${BUILD_GUI})
    endif ()
    # Install kge man page only when GUI is built
    install(FILES docs/kge.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
+    install(FILES kge.png DESTINATION ${CMAKE_INSTALL_PREFIX}/share/icons)
 endif ()
--- a/Command.cc
+++ b/Command.cc
--- a/Command.h
+++ b/Command.h
@@ -23,7 +23,11 @@ enum class CommandId {
 	Refresh, // force redraw
 	KPrefix, // show "C-k _" prompt in status when entering k-command
 	FindStart, // begin incremental search (placeholder)
+	RegexFindStart, // begin regex search (C-r)
+	RegexpReplace, // begin regex search & replace (C-t)
+	SearchReplace, // begin search & replace (two-step prompt)
 	OpenFileStart, // begin open-file prompt
+	VisualFilePickerToggle,
 	// Buffers
 	BufferSwitchStart, // begin buffer switch prompt
 	BufferClose,
@@ -65,10 +69,15 @@ enum class CommandId {
 	Redo,
 	// UI/status helpers
 	UArgStatus, // update status line during universal-argument collection
+	// Themes (GUI)
+	ThemeNext,
+	ThemePrev,
 	// Region formatting
 	IndentRegion, // indent region (C-k =)
 	UnindentRegion, // unindent region (C-k -)
 	ReflowParagraph, // reflow paragraph to column width (ESC q)
+	// Read-only buffers
+	ToggleReadOnly, // toggle current buffer read-only (C-k ')
 	// Buffer operations
 	ReloadBuffer, // reload buffer from disk (C-k l)
 	MarkAllAndJumpEnd, // set mark at beginning, jump to end (C-k a)
@@ -76,8 +85,16 @@ enum class CommandId {
 	JumpToLine, // prompt for line and jump (C-k g)
 	ShowWorkingDirectory, // Display the current working directory in the editor message.
 	ChangeWorkingDirectory, // Change the editor's current directory.
+	// Help
+	ShowHelp, // open +HELP+ buffer with manual text (C-k h)
 	// Meta
 	UnknownKCommand, // arg: single character that was not recognized after C-k
+	// Generic command prompt
+	CommandPromptStart, // begin generic command prompt (C-k ;)
+	// Theme by name
+	ThemeSetByName,
+	// Background mode (GUI)
+	BackgroundSet,
 };


@@ -101,6 +118,8 @@ struct Command {
 	std::string name; // stable, unique name (e.g., "save", "save-as")
 	std::string help; // short help/description
 	CommandHandler handler;
+	// Public commands are exposed in the ": " prompt (C-k ;)
+	bool isPublic = false;
 };


--- a/Editor.cc
+++ b/Editor.cc
@@ -1,9 +1,9 @@
-#include "Editor.h"
-
 #include <algorithm>
 #include <utility>
 #include <filesystem>

+#include "Editor.h"
+

 Editor::Editor() = default;

--- a/Editor.h
+++ b/Editor.h
@@ -302,7 +302,22 @@ public:


 	// --- Generic Prompt subsystem (for search, open-file, save-as, etc.) ---
-	enum class PromptKind { None = 0, Search, OpenFile, SaveAs, Confirm, BufferSwitch, GotoLine, Chdir };
+	enum class PromptKind {
+		None = 0,
+		Search,
+		RegexSearch,
+		RegexReplaceFind, // step 1 of Regex Search & Replace: find pattern
+		RegexReplaceWith, // step 2 of Regex Search & Replace: replacement text
+		OpenFile,
+		SaveAs,
+		Confirm,
+		BufferSwitch,
+		GotoLine,
+		Chdir,
+		ReplaceFind, // step 1 of Search & Replace: find what
+		ReplaceWith, // step 2 of Search & Replace: replace with
+		Command // generic command prompt (": ")
+	};


 	void StartPrompt(PromptKind kind, const std::string &label, const std::string &initial)
@@ -441,6 +456,31 @@ public:
 		return buffers_;
 	}

+
+	// --- GUI: Visual File Picker state ---
+	void SetFilePickerVisible(bool on)
+	{
+		file_picker_visible_ = on;
+	}
+
+
+	[[nodiscard]] bool FilePickerVisible() const
+	{
+		return file_picker_visible_;
+	}
+
+
+	void SetFilePickerDir(const std::string &path)
+	{
+		file_picker_dir_ = path;
+	}
+
+
+	[[nodiscard]] const std::string &FilePickerDir() const
+	{
+		return file_picker_dir_;
+	}
+
 private:
 	std::size_t rows_ = 0, cols_ = 0;
 	int mode_         = 0;
@@ -478,6 +518,39 @@ private:
 	std::string prompt_label_;
 	std::string prompt_text_;
 	std::string pending_overwrite_path_;
+
+	// GUI-only state (safe no-op in terminal builds)
+	bool file_picker_visible_ = false;
+	std::string file_picker_dir_;
+
+	// Temporary state for Search & Replace flow
+public:
+	void SetReplaceFindTmp(const std::string &s)
+	{
+		replace_find_tmp_ = s;
+	}
+
+
+	void SetReplaceWithTmp(const std::string &s)
+	{
+		replace_with_tmp_ = s;
+	}
+
+
+	[[nodiscard]] const std::string &ReplaceFindTmp() const
+	{
+		return replace_find_tmp_;
+	}
+
+
+	[[nodiscard]] const std::string &ReplaceWithTmp() const
+	{
+		return replace_with_tmp_;
+	}
+
+private:
+	std::string replace_find_tmp_;
+	std::string replace_with_tmp_;
 };

 #endif // KTE_EDITOR_H
--- a/Frontend.h
+++ b/Frontend.h
@@ -4,8 +4,6 @@
 #ifndef KTE_FRONTEND_H
 #define KTE_FRONTEND_H

-#include <memory>
-

 class Editor;
 class InputHandler;
--- a/GUIConfig.cc
+++ b/GUIConfig.cc
@@ -0,0 +1,118 @@
+#include <cstdlib>
+#include <cstring>
+#include <fstream>
+#include <sstream>
+#include <algorithm>
+
+#include "GUIConfig.h"
+
+
+static void
+trim(std::string &s)
+{
+	auto not_space = [](int ch) {
+		return !std::isspace(ch);
+	};
+	s.erase(s.begin(), std::find_if(s.begin(), s.end(), not_space));
+	s.erase(std::find_if(s.rbegin(), s.rend(), not_space).base(), s.end());
+}
+
+
+static std::string
+default_config_path()
+{
+	const char *home = std::getenv("HOME");
+	if (!home || !*home)
+		return {};
+	std::string path(home);
+	path += "/.config/kte/kge.ini";
+	return path;
+}
+
+
+GUIConfig
+GUIConfig::Load()
+{
+	GUIConfig cfg; // defaults already set
+	const std::string path = default_config_path();
+
+	if (!path.empty()) {
+		cfg.LoadFromFile(path);
+	}
+	return cfg;
+}
+
+
+bool
+GUIConfig::LoadFromFile(const std::string &path)
+{
+	std::ifstream in(path);
+	if (!in.good())
+		return false;
+
+	std::string line;
+	while (std::getline(in, line)) {
+		// Remove comments starting with '#' or ';'
+		auto hash = line.find('#');
+		if (hash != std::string::npos)
+			line.erase(hash);
+		auto sc = line.find("//");
+		if (sc != std::string::npos)
+			line.erase(sc);
+		// Basic key=value
+		auto eq = line.find('=');
+		if (eq == std::string::npos)
+			continue;
+		std::string key = line.substr(0, eq);
+		std::string val = line.substr(eq + 1);
+		trim(key);
+		trim(val);
+		// Strip trailing semicolon
+		if (!val.empty() && val.back() == ';') {
+			val.pop_back();
+			trim(val);
+		}
+
+		// Lowercase key
+		std::transform(key.begin(), key.end(), key.begin(), [](unsigned char c) {
+			return (char) std::tolower(c);
+		});
+
+		if (key == "fullscreen") {
+			fullscreen = (val == "1" || val == "true" || val == "on" || val == "yes");
+		} else if (key == "columns" || key == "cols") {
+			int v = columns;
+			try {
+				v = std::stoi(val);
+			} catch (...) {}
+			if (v > 0)
+				columns = v;
+		} else if (key == "rows") {
+			int v = rows;
+			try {
+				v = std::stoi(val);
+			} catch (...) {}
+			if (v > 0)
+				rows = v;
+		} else if (key == "font_size" || key == "fontsize") {
+			float v = font_size;
+			try {
+				v = std::stof(val);
+			} catch (...) {}
+			if (v > 0.0f) {
+				font_size = v;
+			}
+		} else if (key == "theme") {
+			theme = val;
+		} else if (key == "background" || key == "bg") {
+			std::string v = val;
+			std::transform(v.begin(), v.end(), v.begin(), [](unsigned char c) {
+				return (char) std::tolower(c);
+			});
+			if (v == "light" || v == "dark")
+				background = v;
+		}
+	}
+
+	return true;
+}
--- a/GUIConfig.h
+++ b/GUIConfig.h
@@ -0,0 +1,31 @@
+/*
+ * GUIConfig - loads simple GUI configuration from $HOME/.config/kte/kge.ini
+ */
+#ifndef KTE_GUI_CONFIG_H
+#define KTE_GUI_CONFIG_H
+
+#include <string>
+
+#ifndef KTE_FONT_SIZE
+#define KTE_FONT_SIZE 16.0f
+#endif
+
+class GUIConfig {
+public:
+	bool fullscreen   = false;
+	int columns       = 80;
+	int rows          = 42;
+	float font_size   = (float) KTE_FONT_SIZE;
+	std::string theme = "nord";
+	// Background mode for themes that support light/dark variants
+	// Values: "dark" (default), "light"
+	std::string background = "dark";
+
+	// Load from default path: $HOME/.config/kte/kge.ini
+	static GUIConfig Load();
+
+	// Load from explicit path. Returns true if file existed and was parsed.
+	bool LoadFromFile(const std::string &path);
+};
+
+#endif // KTE_GUI_CONFIG_H
--- a/GUIFrontend.cc
+++ b/GUIFrontend.cc
@@ -1,18 +1,26 @@
-#include <SDL.h>
-#include <SDL_opengl.h>
-
-#include <imgui.h>
-#include <backends/imgui_impl_sdl2.h>
-#include <backends/imgui_impl_opengl3.h>
 #include <cstdio>
 #include <string>
 #include <cstring>
 #include <cstdlib>
+#include <algorithm>
+
+#include <SDL.h>
+#include <SDL_opengl.h>
+#include <imgui.h>
+#include <backends/imgui_impl_sdl2.h>
+#include <backends/imgui_impl_opengl3.h>

 #include "Editor.h"
 #include "Command.h"
 #include "GUIFrontend.h"
 #include "Font.h" // embedded default font (DefaultFontRegular)
+#include "GUIConfig.h"
+#include "GUITheme.h"
+
+
+#ifndef KTE_FONT_SIZE
+#define KTE_FONT_SIZE 16.0f
+#endif

 static const char *kGlslVersion = "#version 150"; // GL 3.2 core (macOS compatible)

@@ -24,6 +32,9 @@ GUIFrontend::Init(Editor &ed)
 		return false;
 	}

+	// Load GUI configuration (fullscreen, columns/rows, font size, theme, background)
+	GUIConfig cfg = GUIConfig::Load();
+
 	// GL attributes for core profile
 	SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, 0);
 	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
@@ -33,14 +44,56 @@ GUIFrontend::Init(Editor &ed)
 	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
 	SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);

+	// Compute desired window size from config
+	Uint32 win_flags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI;
+
+	if (cfg.fullscreen) {
+		// "Fullscreen": fill the usable bounds of the primary display.
+		// On macOS, do NOT use true fullscreen so the menu/status bar remains visible.
+		SDL_Rect usable{};
+		if (SDL_GetDisplayUsableBounds(0, &usable) == 0) {
+			width_  = usable.w;
+			height_ = usable.h;
+		}
+#if !defined(__APPLE__)
+		// Non-macOS: desktop fullscreen uses the current display resolution.
+		win_flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
+#endif
+	} else {
+		// Windowed: width = columns * font_size, height = (rows * 2) * font_size
+		int w = cfg.columns * static_cast<int>(cfg.font_size);
+		int h = cfg.rows * static_cast<int>(cfg.font_size * 1.2);
+
+		// As a safety, clamp to display usable bounds if retrievable
+		SDL_Rect usable{};
+		if (SDL_GetDisplayUsableBounds(0, &usable) == 0) {
+			w = std::min(w, usable.w);
+			h = std::min(h, usable.h);
+		}
+		width_  = std::max(320, w);
+		height_ = std::max(200, h);
+	}
+
 	window_ = SDL_CreateWindow(
-		"kte",
+		"kge - kyle's graphical editor " KTE_VERSION_STR,
 		SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
 		width_, height_,
-		SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
+		win_flags);
 	if (!window_)
 		return false;

+#if defined(__APPLE__)
+	// macOS: when "fullscreen" is requested, position the window at the
+	// top-left of the usable display area to mimic fullscreen while keeping
+	// the system menu bar visible.
+	if (cfg.fullscreen) {
+		SDL_Rect usable{};
+		if (SDL_GetDisplayUsableBounds(0, &usable) == 0) {
+			SDL_SetWindowPosition(window_, usable.x, usable.y);
+		}
+	}
+#endif
+
 	gl_ctx_ = SDL_GL_CreateContext(window_);
 	if (!gl_ctx_)
 		return false;
@@ -53,6 +106,13 @@ GUIFrontend::Init(Editor &ed)
 	(void) io;
 	ImGui::StyleColorsDark();

+	// Apply background mode and selected theme (default: Nord). Can be changed at runtime via commands.
+	if (cfg.background == "light")
+		kte::SetBackgroundMode(kte::BackgroundMode::Light);
+	else
+		kte::SetBackgroundMode(kte::BackgroundMode::Dark);
+	kte::ApplyThemeByName(cfg.theme);
+
 	if (!ImGui_ImplSDL2_InitForOpenGL(window_, gl_ctx_))
 		return false;
 	if (!ImGui_ImplOpenGL3_Init(kGlslVersion))
@@ -64,11 +124,23 @@ GUIFrontend::Init(Editor &ed)
 	width_  = w;
 	height_ = h;

-	// Initialize GUI font from embedded default
-#ifndef KTE_FONT_SIZE
-#define KTE_FONT_SIZE 16.0f
+#if defined(__APPLE__)
+	// Workaround: On macOS Retina when starting maximized, we sometimes get a
+	// subtle input vs draw alignment mismatch until the first manual resize.
+	// Nudge the window size by 1px and back to trigger a proper internal
+	// recomputation, without visible impact.
+	if (w > 1 && h > 1) {
+		SDL_SetWindowSize(window_, w - 1, h - 1);
+		SDL_SetWindowSize(window_, w, h);
+		// Update cached size in case backend reports immediately
+		SDL_GetWindowSize(window_, &w, &h);
+		width_  = w;
+		height_ = h;
+	}
 #endif
-	LoadGuiFont_(nullptr, (float) KTE_FONT_SIZE);
+
+	// Initialize GUI font from embedded default (use configured size or compiled default)
+	LoadGuiFont_(nullptr, (float) cfg.font_size);

 	return true;
 }
@@ -147,7 +219,7 @@ GUIFrontend::Step(Editor &ed, bool &running)
 		float avail_h = std::max(0.0f, disp_h - 2.0f * pad_y - status_h);

 		// Visible content rows inside the scroll child
-		std::size_t content_rows = static_cast<std::size_t>(std::floor(avail_h / line_h));
+		auto content_rows = static_cast<std::size_t>(std::floor(avail_h / line_h));
 		// Editor::Rows includes the status line; add 1 back for it.
 		std::size_t rows = std::max<std::size_t>(1, content_rows + 1);
 		std::size_t cols = static_cast<std::size_t>(std::max(1.0f, std::floor(avail_w / ch_w)));
@@ -197,11 +269,11 @@ GUIFrontend::Shutdown()
 bool
 GUIFrontend::LoadGuiFont_(const char * /*path*/, float size_px)
 {
-	ImGuiIO &io = ImGui::GetIO();
+	const ImGuiIO &io = ImGui::GetIO();
 	io.Fonts->Clear();
-	ImFont *font = io.Fonts->AddFontFromMemoryCompressedTTF(
-		(void *) DefaultFontRegularCompressedData,
-		(int) DefaultFontRegularCompressedSize,
+	const ImFont *font = io.Fonts->AddFontFromMemoryCompressedTTF(
+		DefaultFontBoldCompressedData,
+		DefaultFontBoldCompressedSize,
 		size_px);
 	if (!font) {
 		font = io.Fonts->AddFontDefault();
--- a/GUIFrontend.h
+++ b/GUIFrontend.h
@@ -8,6 +8,7 @@
 #include "GUIInputHandler.h"
 #include "GUIRenderer.h"

+
 struct SDL_Window;
 typedef void *SDL_GLContext;

@@ -24,7 +25,7 @@ public:
 	void Shutdown() override;

 private:
-	bool LoadGuiFont_(const char *path, float size_px);
+	static bool LoadGuiFont_(const char *path, float size_px);

 	GUIInputHandler input_{};
 	GUIRenderer renderer_{};
--- a/GUIInputHandler.cc
+++ b/GUIInputHandler.cc
@@ -1,7 +1,9 @@
-#include <SDL.h>
 #include <cstdio>
+#include <algorithm>
 #include <ncurses.h>

+#include <SDL.h>
+
 #include "GUIInputHandler.h"
 #include "KKeymap.h"

@@ -90,12 +92,14 @@ map_key(const SDL_Keycode key,
 		out = {true, CommandId::Backspace, "", 0};
 		return true;
 	case SDLK_TAB:
-		// Insert a literal tab character
-		out.hasCommand = true;
-		out.id    = CommandId::InsertText;
-		out.arg   = "\t";
-		out.count = 0;
-		return true;
+		// Insert a literal tab character when not interpreting a k-prefix suffix.
+		// If k-prefix is active, let the k-prefix handler below consume the key
+		// (so Tab doesn't leave k-prefix stuck).
+		if (!k_prefix) {
+			out = {true, CommandId::InsertText, std::string("\t"), 0};
+			return true;
+		}
+		break; // fall through so k-prefix handler can process
 	case SDLK_RETURN:
 	case SDLK_KP_ENTER:
 		out = {true, CommandId::Newline, "", 0};
@@ -347,6 +351,12 @@ GUIInputHandler::ProcessSDLEvent(const SDL_Event &e)
 		                   uarg_text_,
 		                   mi);

+		// If we inserted a TAB on KEYDOWN, suppress any subsequent SDL_TEXTINPUT
+		// for this keystroke to avoid double insertion on platforms that emit it.
+		if (produced && mi.hasCommand && mi.id == CommandId::InsertText && mi.arg == "\t") {
+			suppress_text_input_once_ = true;
+		}
+
 		// If we just consumed a universal-argument digit or '-' on KEYDOWN and emitted UArgStatus,
 		// suppress the subsequent SDL_TEXTINPUT for this keystroke to avoid duplicating the digit in status.
 		if (produced && mi.hasCommand && mi.id == CommandId::UArgStatus) {
@@ -519,11 +529,21 @@ GUIInputHandler::ProcessSDLEvent(const SDL_Event &e)
 			break;
 		}
 		if (!k_prefix_ && e.text.text[0] != '\0') {
-			mi.hasCommand = true;
-			mi.id         = CommandId::InsertText;
-			mi.arg        = std::string(e.text.text);
-			mi.count      = 0;
-			produced      = true;
+			// Ensure InsertText never carries a newline; those must originate from KEYDOWN
+			std::string text(e.text.text);
+			// Strip any CR/LF that might slip through from certain platforms/IME behaviors
+			text.erase(std::remove(text.begin(), text.end(), '\n'), text.end());
+			text.erase(std::remove(text.begin(), text.end(), '\r'), text.end());
+			if (!text.empty()) {
+				mi.hasCommand = true;
+				mi.id         = CommandId::InsertText;
+				mi.arg        = std::move(text);
+				mi.count      = 0;
+				produced      = true;
+			} else {
+				// Nothing to insert after filtering; consume the event
+				produced = true;
+			}
 		} else {
 			produced = true; // consumed while k-prefix is active
 		}
--- a/GUIInputHandler.h
+++ b/GUIInputHandler.h
@@ -4,11 +4,12 @@
 #ifndef KTE_GUI_INPUT_HANDLER_H
 #define KTE_GUI_INPUT_HANDLER_H

-#include <queue>
 #include <mutex>
+#include <queue>

 #include "InputHandler.h"

+
 union SDL_Event; // fwd decl to avoid including SDL here (SDL defines SDL_Event as a union)

 class GUIInputHandler final : public InputHandler {
--- a/GUIRenderer.cc
+++ b/GUIRenderer.cc
@@ -1,31 +1,51 @@
-#include "GUIRenderer.h"
-
-#include "Editor.h"
-#include "Buffer.h"
-#include "Command.h"
+#include <algorithm>
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <filesystem>
+#include <limits>
+#include <string>

 #include <imgui.h>
-#include <cstdio>
-#include <string>
-#include <filesystem>
-#include <cmath>
-#include <limits>
+#include <regex>
+
+#include "GUIRenderer.h"
+#include "Buffer.h"
+#include "Command.h"
+#include "Editor.h"
+

 // Version string expected to be provided by build system as KTE_VERSION_STR
 #ifndef KTE_VERSION_STR
 #  define KTE_VERSION_STR "dev"
 #endif

+// ImGui compatibility: some bundled ImGui versions (or builds without docking)
+// don't define ImGuiWindowFlags_NoDocking. Treat it as 0 in that case.
+#ifndef ImGuiWindowFlags_NoDocking
+#  define ImGuiWindowFlags_NoDocking 0
+#endif
+

 void
 GUIRenderer::Draw(Editor &ed)
 {
 	// Make the editor window occupy the entire GUI container/viewport
 	ImGuiViewport *vp = ImGui::GetMainViewport();
-	ImGui::SetNextWindowPos(vp->Pos);
-	ImGui::SetNextWindowSize(vp->Size);
+	// On HiDPI/Retina, snap to integer pixels to prevent any draw vs hit-test
+	// mismatches that can appear on the very first maximized frame.
+	ImVec2 main_pos = vp->Pos;
+	ImVec2 main_sz  = vp->Size;
+	main_pos.x      = std::floor(main_pos.x + 0.5f);
+	main_pos.y      = std::floor(main_pos.y + 0.5f);
+	main_sz.x       = std::floor(main_sz.x + 0.5f);
+	main_sz.y       = std::floor(main_sz.y + 0.5f);
+	ImGui::SetNextWindowPos(main_pos);
+	ImGui::SetNextWindowSize(main_sz);

 	ImGuiWindowFlags flags = ImGuiWindowFlags_NoTitleBar
+	                         | ImGuiWindowFlags_NoScrollbar
+	                         | ImGuiWindowFlags_NoScrollWithMouse
 	                         | ImGuiWindowFlags_NoResize
 	                         | ImGuiWindowFlags_NoMove
 	                         | ImGuiWindowFlags_NoCollapse
@@ -167,19 +187,47 @@ GUIRenderer::Draw(Editor &ed)
 			if (px < 0.0f)
 				px = 0.0f;

-			// Convert pixel X to a render-column target including horizontal col offset
-			// Use our own tab expansion of width 8 to match command layer logic.
-			const std::string &line_clicked = lines[by];
-			const std::size_t tabw          = 8;
-			// We iterate source columns computing absolute rendered column (rx_abs) from 0,
-			// then translate to viewport-space by subtracting Coloffs.
-			std::size_t coloffs = buf->Coloffs();
-			std::size_t rx_abs  = 0; // absolute rendered column
-			std::size_t i       = 0; // source column iterator
+			// Empty buffer guard: if there are no lines yet, just move to 0:0
+			if (lines.empty()) {
+				Execute(ed, CommandId::MoveCursorTo, std::string("0:0"));
+			} else {
+				// Convert pixel X to a render-column target including horizontal col offset
+				// Use our own tab expansion of width 8 to match command layer logic.
+				std::string line_clicked = static_cast<std::string>(lines[by]);
+				const std::size_t tabw   = 8;
+				// We iterate source columns computing absolute rendered column (rx_abs) from 0,
+				// then translate to viewport-space by subtracting Coloffs.
+				std::size_t coloffs = buf->Coloffs();
+				std::size_t rx_abs  = 0; // absolute rendered column
+				std::size_t i       = 0; // source column iterator

-			// Fast-forward i until rx_abs >= coloffs to align with leftmost visible column
-			if (!line_clicked.empty() && coloffs > 0) {
-				while (i < line_clicked.size() && rx_abs < coloffs) {
+				// Fast-forward i until rx_abs >= coloffs to align with leftmost visible column
+				if (!line_clicked.empty() && coloffs > 0) {
+					while (i < line_clicked.size() && rx_abs < coloffs) {
+						if (line_clicked[i] == '\t') {
+							rx_abs += (tabw - (rx_abs % tabw));
+						} else {
+							rx_abs += 1;
+						}
+						++i;
+					}
+				}
+
+				// Now search for closest source column to clicked px within/after viewport
+				std::size_t best_col = i; // default to first visible column
+				float best_dist      = std::numeric_limits<float>::infinity();
+				while (true) {
+					// For i in [current..size], evaluate candidate including the implicit end position
+					std::size_t rx_view = (rx_abs >= coloffs) ? (rx_abs - coloffs) : 0;
+					float rx_px         = static_cast<float>(rx_view) * space_w;
+					float dist          = std::fabs(px - rx_px);
+					if (dist <= best_dist) {
+						best_dist = dist;
+						best_col  = i;
+					}
+					if (i == line_clicked.size())
+						break;
+					// advance to next source column
 					if (line_clicked[i] == '\t') {
 						rx_abs += (tabw - (rx_abs % tabw));
 					} else {
@@ -187,48 +235,92 @@ GUIRenderer::Draw(Editor &ed)
 					}
 					++i;
 				}
-			}

-			// Now search for closest source column to clicked px within/after viewport
-			std::size_t best_col = i; // default to first visible column
-			float best_dist      = std::numeric_limits<float>::infinity();
-			while (true) {
-				// For i in [current..size], evaluate candidate including the implicit end position
-				std::size_t rx_view = (rx_abs >= coloffs) ? (rx_abs - coloffs) : 0;
-				float rx_px         = static_cast<float>(rx_view) * space_w;
-				float dist          = std::fabs(px - rx_px);
-				if (dist <= best_dist) {
-					best_dist = dist;
-					best_col  = i;
-				}
-				if (i == line_clicked.size())
-					break;
-				// advance to next source column
-				if (line_clicked[i] == '\t') {
-					rx_abs += (tabw - (rx_abs % tabw));
-				} else {
-					rx_abs += 1;
-				}
-				++i;
+				// Dispatch absolute buffer coordinates (row:col)
+				char tmp[64];
+				std::snprintf(tmp, sizeof(tmp), "%zu:%zu", by, best_col);
+				Execute(ed, CommandId::MoveCursorTo, std::string(tmp));
 			}
-
-			// Dispatch absolute buffer coordinates (row:col)
-			char tmp[64];
-			std::snprintf(tmp, sizeof(tmp), "%zu:%zu", by, best_col);
-			Execute(ed, CommandId::MoveCursorTo, std::string(tmp));
 		}
 		// Cache current horizontal offset in rendered columns
 		const std::size_t coloffs_now = buf->Coloffs();
 		for (std::size_t i = rowoffs; i < lines.size(); ++i) {
 			// Capture the screen position before drawing the line
-			ImVec2 line_pos         = ImGui::GetCursorScreenPos();
-			const std::string &line = lines[i];
+			ImVec2 line_pos  = ImGui::GetCursorScreenPos();
+			std::string line = static_cast<std::string>(lines[i]);

 			// Expand tabs to spaces with width=8 and apply horizontal scroll offset
 			const std::size_t tabw = 8;
 			std::string expanded;
 			expanded.reserve(line.size() + 16);
 			std::size_t rx_abs_draw = 0; // rendered column for drawing
+			// Compute search highlight ranges for this line in source indices
+			bool search_mode = ed.SearchActive() && !ed.SearchQuery().empty();
+			std::vector<std::pair<std::size_t, std::size_t> > hl_src_ranges;
+			if (search_mode) {
+				// If we're in RegexSearch or RegexReplaceFind mode, compute ranges using regex; otherwise plain substring
+				if (ed.PromptActive() && (
+					    ed.CurrentPromptKind() == Editor::PromptKind::RegexSearch || ed.
+					    CurrentPromptKind() == Editor::PromptKind::RegexReplaceFind)) {
+					try {
+						std::regex rx(ed.SearchQuery());
+						for (auto it = std::sregex_iterator(line.begin(), line.end(), rx);
+						     it != std::sregex_iterator(); ++it) {
+							const auto &m  = *it;
+							std::size_t sx = static_cast<std::size_t>(m.position());
+							std::size_t ex = sx + static_cast<std::size_t>(m.length());
+							hl_src_ranges.emplace_back(sx, ex);
+						}
+					} catch (const std::regex_error &) {
+						// ignore invalid patterns here; status line already shows the error
+					}
+				} else {
+					const std::string &q = ed.SearchQuery();
+					std::size_t pos      = 0;
+					while (!q.empty() && (pos = line.find(q, pos)) != std::string::npos) {
+						hl_src_ranges.emplace_back(pos, pos + q.size());
+						pos += q.size();
+					}
+				}
+			}
+			auto src_to_rx = [&](std::size_t upto_src_exclusive) -> std::size_t {
+				std::size_t rx = 0;
+				std::size_t s  = 0;
+				while (s < upto_src_exclusive && s < line.size()) {
+					if (line[s] == '\t')
+						rx += (tabw - (rx % tabw));
+					else
+						rx += 1;
+					++s;
+				}
+				return rx;
+			};
+			// Draw background highlights (under text)
+			if (search_mode && !hl_src_ranges.empty()) {
+				// Current match emphasis
+				bool has_current    = ed.SearchMatchLen() > 0 && ed.SearchMatchY() == i;
+				std::size_t cur_x   = has_current ? ed.SearchMatchX() : 0;
+				std::size_t cur_end = has_current ? (ed.SearchMatchX() + ed.SearchMatchLen()) : 0;
+				for (const auto &rg: hl_src_ranges) {
+					std::size_t sx       = rg.first, ex = rg.second;
+					std::size_t rx_start = src_to_rx(sx);
+					std::size_t rx_end   = src_to_rx(ex);
+					// Apply horizontal scroll offset
+					if (rx_end <= coloffs_now)
+						continue; // fully left of view
+					std::size_t vx0 = (rx_start > coloffs_now) ? (rx_start - coloffs_now) : 0;
+					std::size_t vx1 = rx_end - coloffs_now;
+					ImVec2 p0 = ImVec2(line_pos.x + static_cast<float>(vx0) * space_w, line_pos.y);
+					ImVec2 p1 = ImVec2(line_pos.x + static_cast<float>(vx1) * space_w,
+					                   line_pos.y + line_h);
+					// Choose color: current match stronger
+					bool is_current = has_current && sx == cur_x && ex == cur_end;
+					ImU32 col       = is_current
+						                  ? IM_COL32(255, 220, 120, 140)
+						                  : IM_COL32(200, 200, 0, 90);
+					ImGui::GetWindowDrawList()->AddRectFilled(p0, p1, col);
+				}
+			}
 			// Emit entire line (ImGui child scrolling will handle clipping)
 			for (std::size_t src = 0; src < line.size(); ++src) {
 				char c = line[src];
@@ -268,7 +360,6 @@ GUIRenderer::Draw(Editor &ed)
 		// Status bar spanning full width
 		ImGui::Separator();

-		// Build three segments: left (app/version/buffer/dirty), middle (message), right (cursor/mark)
 		// Compute full content width and draw a filled background rectangle
 		ImVec2 win_pos = ImGui::GetWindowPos();
 		ImVec2 cr_min  = ImGui::GetWindowContentRegionMin();
@@ -281,102 +372,356 @@ GUIRenderer::Draw(Editor &ed)
 		ImVec2 p1(x1, cursor.y + bar_h);
 		ImU32 bg_col = ImGui::GetColorU32(ImGuiCol_HeaderActive);
 		ImGui::GetWindowDrawList()->AddRectFilled(p0, p1, bg_col);
-		// Build left text
-		std::string left;
-		left.reserve(256);
-		left += "kge"; // GUI app name
-		left += " ";
-		left += KTE_VERSION_STR;
-		std::string fname;
-		try {
-			fname = ed.DisplayNameFor(*buf);
-		} catch (...) {
-			fname = buf->Filename();
-			try {
-				fname = std::filesystem::path(fname).filename().string();
-			} catch (...) {}
-		}
-		left += "  ";
-		left += fname;
-		if (buf->Dirty())
-			left += " *";
-		// Append total line count as "<n>L"
-		{
-			unsigned long lcount = static_cast<unsigned long>(buf->Rows().size());
-			left += " ";
-			left += std::to_string(lcount);
-			left += "L";
-		}
-
-		// Build right text (cursor/mark)
-		int row1       = static_cast<int>(buf->Cury()) + 1;
-		int col1       = static_cast<int>(buf->Curx()) + 1;
-		bool have_mark = buf->MarkSet();
-		int mrow1      = have_mark ? static_cast<int>(buf->MarkCury()) + 1 : 0;
-		int mcol1      = have_mark ? static_cast<int>(buf->MarkCurx()) + 1 : 0;
-		char rbuf[128];
-		if (have_mark)
-			std::snprintf(rbuf, sizeof(rbuf), "%d,%d | M: %d,%d", row1, col1, mrow1, mcol1);
-		else
-			std::snprintf(rbuf, sizeof(rbuf), "%d,%d | M: not set", row1, col1);
-		std::string right = rbuf;
-
-		// Middle message: if a prompt is active, show "Label: text"; otherwise show status
-		std::string msg;
+		// If a prompt is active, replace the entire status bar with the prompt text
 		if (ed.PromptActive()) {
-			msg = ed.PromptLabel();
-			if (!msg.empty())
-				msg += ": ";
-			msg += ed.PromptText();
-		} else {
-			msg = ed.Status();
-		}
+			std::string label = ed.PromptLabel();
+			std::string ptext = ed.PromptText();
+			auto kind         = ed.CurrentPromptKind();
+			if (kind == Editor::PromptKind::OpenFile || kind == Editor::PromptKind::SaveAs ||
+			    kind == Editor::PromptKind::Chdir) {
+				const char *home_c = std::getenv("HOME");
+				if (home_c && *home_c) {
+					std::string home(home_c);
+					if (ptext.rfind(home, 0) == 0) {
+						std::string rest = ptext.substr(home.size());
+						if (rest.empty())
+							ptext = "~";
+						else if (!rest.empty() && (rest[0] == '/' || rest[0] == '\\'))
+							ptext = std::string("~") + rest;
+					}
+				}
+			}

-		// Measurements
-		ImVec2 left_sz  = ImGui::CalcTextSize(left.c_str());
-		ImVec2 right_sz = ImGui::CalcTextSize(right.c_str());
-		float pad       = 6.f;
-		float left_x    = p0.x + pad;
-		float right_x   = p1.x - pad - right_sz.x;
-		if (right_x < left_x + left_sz.x + pad) {
-			// Not enough room; clip left to fit
-			float max_left = std::max(0.0f, right_x - left_x - pad);
-			if (max_left < left_sz.x && max_left > 10.0f) {
-				// Render a clipped left using a child region
+			float pad     = 6.f;
+			float left_x  = p0.x + pad;
+			float right_x = p1.x - pad;
+			float max_px  = std::max(0.0f, right_x - left_x);
+
+			std::string prefix;
+			if (kind == Editor::PromptKind::Command) {
+				prefix = ": ";
+			} else if (!label.empty()) {
+				prefix = label + ": ";
+			}
+
+			// Compose showing right-end of filename portion when too long for space
+			std::string final_msg;
+			ImVec2 prefix_sz = ImGui::CalcTextSize(prefix.c_str());
+			float avail_px   = std::max(0.0f, max_px - prefix_sz.x);
+			if ((kind == Editor::PromptKind::OpenFile || kind == Editor::PromptKind::SaveAs || kind ==
+			     Editor::PromptKind::Chdir) && avail_px > 0.0f) {
+				// Trim from left until it fits by pixel width
+				std::string tail = ptext;
+				ImVec2 tail_sz   = ImGui::CalcTextSize(tail.c_str());
+				if (tail_sz.x > avail_px) {
+					// Remove leading chars until it fits
+					// Use a simple loop; text lengths are small here
+					size_t start = 0;
+					// To avoid O(n^2) worst-case, remove chunks
+					while (start < tail.size()) {
+						// Estimate how many chars to skip based on ratio
+						float ratio = tail_sz.x / avail_px;
+						size_t skip = ratio > 1.5f
+							              ? std::min(tail.size() - start,
+								              (size_t) std::max<size_t>(
+									              1, (size_t) (tail.size() / 4)))
+							              : 1;
+						start += skip;
+						std::string candidate = tail.substr(start);
+						ImVec2 cand_sz        = ImGui::CalcTextSize(candidate.c_str());
+						if (cand_sz.x <= avail_px) {
+							tail    = candidate;
+							tail_sz = cand_sz;
+							break;
+						}
+					}
+					if (ImGui::CalcTextSize(tail.c_str()).x > avail_px && !tail.empty()) {
+						// As a last resort, ensure fit by chopping exactly
+						// binary reduce
+						size_t lo = 0, hi = tail.size();
+						while (lo < hi) {
+							size_t mid       = (lo + hi) / 2;
+							std::string cand = tail.substr(mid);
+							if (ImGui::CalcTextSize(cand.c_str()).x <= avail_px)
+								hi = mid;
+							else
+								lo = mid + 1;
+						}
+						tail = tail.substr(lo);
+					}
+				}
+				final_msg = prefix + tail;
+			} else {
+				final_msg = prefix + ptext;
+			}
+
+			ImVec2 msg_sz = ImGui::CalcTextSize(final_msg.c_str());
+			ImGui::PushClipRect(ImVec2(p0.x, p0.y), ImVec2(p1.x, p1.y), true);
+			ImGui::SetCursorScreenPos(ImVec2(left_x, p0.y + (bar_h - msg_sz.y) * 0.5f));
+			ImGui::TextUnformatted(final_msg.c_str());
+			ImGui::PopClipRect();
+			// Advance cursor to after the bar to keep layout consistent
+			ImGui::Dummy(ImVec2(x1 - x0, bar_h));
+		} else {
+			// Build left text
+			std::string left;
+			left.reserve(256);
+			left += "kge"; // GUI app name
+			left += " ";
+			left += KTE_VERSION_STR;
+			std::string fname;
+			try {
+				fname = ed.DisplayNameFor(*buf);
+			} catch (...) {
+				fname = buf->Filename();
+				try {
+					fname = std::filesystem::path(fname).filename().string();
+				} catch (...) {}
+			}
+			left += "  ";
+			// Insert buffer position prefix "[x/N] " before filename
+			{
+				std::size_t total = ed.BufferCount();
+				if (total > 0) {
+					std::size_t idx1 = ed.CurrentBufferIndex() + 1; // 1-based for display
+					left += "[";
+					left += std::to_string(static_cast<unsigned long long>(idx1));
+					left += "/";
+					left += std::to_string(static_cast<unsigned long long>(total));
+					left += "] ";
+				}
+			}
+			left += fname;
+			if (buf->Dirty())
+				left += " *";
+			// Append total line count as "<n>L"
+			{
+				unsigned long lcount = static_cast<unsigned long>(buf->Rows().size());
+				left += " ";
+				left += std::to_string(lcount);
+				left += "L";
+			}
+
+			// Build right text (cursor/mark)
+			int row1       = static_cast<int>(buf->Cury()) + 1;
+			int col1       = static_cast<int>(buf->Curx()) + 1;
+			bool have_mark = buf->MarkSet();
+			int mrow1      = have_mark ? static_cast<int>(buf->MarkCury()) + 1 : 0;
+			int mcol1      = have_mark ? static_cast<int>(buf->MarkCurx()) + 1 : 0;
+			char rbuf[128];
+			if (have_mark)
+				std::snprintf(rbuf, sizeof(rbuf), "%d,%d | M: %d,%d", row1, col1, mrow1, mcol1);
+			else
+				std::snprintf(rbuf, sizeof(rbuf), "%d,%d | M: not set", row1, col1);
+			std::string right = rbuf;
+
+			// Middle message: if a prompt is active, show "Label: text"; otherwise show status
+			std::string msg;
+			if (ed.PromptActive()) {
+				msg = ed.PromptLabel();
+				if (!msg.empty())
+					msg += ": ";
+				msg += ed.PromptText();
+			} else {
+				msg = ed.Status();
+			}
+
+			// Measurements
+			ImVec2 left_sz  = ImGui::CalcTextSize(left.c_str());
+			ImVec2 right_sz = ImGui::CalcTextSize(right.c_str());
+			float pad       = 6.f;
+			float left_x    = p0.x + pad;
+			float right_x   = p1.x - pad - right_sz.x;
+			if (right_x < left_x + left_sz.x + pad) {
+				// Not enough room; clip left to fit
+				float max_left = std::max(0.0f, right_x - left_x - pad);
+				if (max_left < left_sz.x && max_left > 10.0f) {
+					// Render a clipped left using a child region
+					ImGui::SetCursorScreenPos(ImVec2(left_x, p0.y + (bar_h - left_sz.y) * 0.5f));
+					ImGui::PushClipRect(ImVec2(left_x, p0.y), ImVec2(right_x - pad, p1.y), true);
+					ImGui::TextUnformatted(left.c_str());
+					ImGui::PopClipRect();
+				}
+			} else {
+				// Draw left normally
 				ImGui::SetCursorScreenPos(ImVec2(left_x, p0.y + (bar_h - left_sz.y) * 0.5f));
-				ImGui::PushClipRect(ImVec2(left_x, p0.y), ImVec2(right_x - pad, p1.y), true);
 				ImGui::TextUnformatted(left.c_str());
-				ImGui::PopClipRect();
 			}
-		} else {
-			// Draw left normally
-			ImGui::SetCursorScreenPos(ImVec2(left_x, p0.y + (bar_h - left_sz.y) * 0.5f));
-			ImGui::TextUnformatted(left.c_str());
-		}

-		// Draw right
-		ImGui::SetCursorScreenPos(ImVec2(std::max(right_x, left_x), p0.y + (bar_h - right_sz.y) * 0.5f));
-		ImGui::TextUnformatted(right.c_str());
+			// Draw right
+			ImGui::SetCursorScreenPos(ImVec2(std::max(right_x, left_x),
+			                                 p0.y + (bar_h - right_sz.y) * 0.5f));
+			ImGui::TextUnformatted(right.c_str());

-		// Draw middle message centered in remaining space
-		if (!msg.empty()) {
-			float mid_left  = left_x + left_sz.x + pad;
-			float mid_right = std::max(right_x - pad, mid_left);
-			float mid_w     = std::max(0.0f, mid_right - mid_left);
-			if (mid_w > 1.0f) {
-				ImVec2 msg_sz = ImGui::CalcTextSize(msg.c_str());
-				float msg_x   = mid_left + std::max(0.0f, (mid_w - msg_sz.x) * 0.5f);
-				// Clip to middle region
-				ImGui::PushClipRect(ImVec2(mid_left, p0.y), ImVec2(mid_right, p1.y), true);
-				ImGui::SetCursorScreenPos(ImVec2(msg_x, p0.y + (bar_h - msg_sz.y) * 0.5f));
-				ImGui::TextUnformatted(msg.c_str());
-				ImGui::PopClipRect();
+			// Draw middle message centered in remaining space
+			if (!msg.empty()) {
+				float mid_left  = left_x + left_sz.x + pad;
+				float mid_right = std::max(right_x - pad, mid_left);
+				float mid_w     = std::max(0.0f, mid_right - mid_left);
+				if (mid_w > 1.0f) {
+					ImVec2 msg_sz = ImGui::CalcTextSize(msg.c_str());
+					float msg_x   = mid_left + std::max(0.0f, (mid_w - msg_sz.x) * 0.5f);
+					// Clip to middle region
+					ImGui::PushClipRect(ImVec2(mid_left, p0.y), ImVec2(mid_right, p1.y), true);
+					ImGui::SetCursorScreenPos(ImVec2(msg_x, p0.y + (bar_h - msg_sz.y) * 0.5f));
+					ImGui::TextUnformatted(msg.c_str());
+					ImGui::PopClipRect();
+				}
 			}
+			// Advance cursor to after the bar to keep layout consistent
+			ImGui::Dummy(ImVec2(x1 - x0, bar_h));
 		}
-		// Advance cursor to after the bar to keep layout consistent
-		ImGui::Dummy(ImVec2(x1 - x0, bar_h));
 	}

 	ImGui::End();
 	ImGui::PopStyleVar(3);
+
+	// --- Visual File Picker overlay (GUI only) ---
+	if (ed.FilePickerVisible()) {
+		// Centered popup-style window that always fits within the current viewport
+		ImGuiViewport *vp2 = ImGui::GetMainViewport();
+
+		// Desired size, min size, and margins
+		const ImVec2 want(800.0f, 500.0f);
+		const ImVec2 min_sz(240.0f, 160.0f);
+		const float margin = 20.0f; // space from viewport edges
+
+		// Compute the maximum allowed size (viewport minus margins) and make sure it's not negative
+		ImVec2 max_sz(std::max(32.0f, vp2->Size.x - 2.0f * margin),
+		              std::max(32.0f, vp2->Size.y - 2.0f * margin));
+
+		// Clamp desired size to [min_sz, max_sz]
+		ImVec2 size(std::min(want.x, max_sz.x), std::min(want.y, max_sz.y));
+		size.x = std::max(size.x, std::min(min_sz.x, max_sz.x));
+		size.y = std::max(size.y, std::min(min_sz.y, max_sz.y));
+
+		// Center within the viewport using the final size
+		ImVec2 pos(vp2->Pos.x + std::max(margin, (vp2->Size.x - size.x) * 0.5f),
+		           vp2->Pos.y + std::max(margin, (vp2->Size.y - size.y) * 0.5f));
+
+		// On HiDPI displays (macOS Retina), ensure integer pixel alignment to avoid
+		// potential hit-test vs draw mismatches from sub-pixel positions.
+		pos.x  = std::floor(pos.x + 0.5f);
+		pos.y  = std::floor(pos.y + 0.5f);
+		size.x = std::floor(size.x + 0.5f);
+		size.y = std::floor(size.y + 0.5f);
+
+		ImGui::SetNextWindowPos(pos, ImGuiCond_Always);
+		ImGui::SetNextWindowSize(size, ImGuiCond_Always);
+		ImGuiWindowFlags wflags = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse |
+		                          ImGuiWindowFlags_NoDocking;
+		bool open = true;
+		if (ImGui::Begin("File Picker", &open, wflags)) {
+			// Current directory
+			std::string curdir = ed.FilePickerDir();
+			if (curdir.empty()) {
+				try {
+					curdir = std::filesystem::current_path().string();
+				} catch (...) {
+					curdir = ".";
+				}
+				ed.SetFilePickerDir(curdir);
+			}
+			ImGui::TextUnformatted(curdir.c_str());
+			ImGui::SameLine();
+			if (ImGui::Button("Up")) {
+				try {
+					std::filesystem::path p(curdir);
+					if (p.has_parent_path()) {
+						ed.SetFilePickerDir(p.parent_path().string());
+					}
+				} catch (...) {}
+			}
+			ImGui::SameLine();
+			if (ImGui::Button("Close")) {
+				ed.SetFilePickerVisible(false);
+			}
+
+			ImGui::Separator();
+
+			// Header
+			ImGui::TextUnformatted("Name");
+			ImGui::Separator();
+
+			// Scrollable list
+			ImGui::BeginChild("picker-list", ImVec2(0, 0), true);
+
+			// Build entries: directories first then files, alphabetical
+			struct Entry {
+				std::string name;
+				std::filesystem::path path;
+				bool is_dir;
+			};
+			std::vector<Entry> entries;
+			entries.reserve(256);
+			// Optional parent entry
+			try {
+				std::filesystem::path base(curdir);
+				std::error_code ec;
+				for (auto it = std::filesystem::directory_iterator(base, ec);
+				     !ec && it != std::filesystem::directory_iterator(); it.increment(ec)) {
+					const auto &p = it->path();
+					std::string nm;
+					try {
+						nm = p.filename().string();
+					} catch (...) {
+						continue;
+					}
+					if (nm == "." || nm == "..")
+						continue;
+					bool is_dir = false;
+					std::error_code ec2;
+					is_dir = it->is_directory(ec2);
+					entries.push_back({nm, p, is_dir});
+				}
+			} catch (...) {
+				// ignore listing errors; show empty
+			}
+			std::sort(entries.begin(), entries.end(), [](const Entry &a, const Entry &b) {
+				if (a.is_dir != b.is_dir)
+					return a.is_dir && !b.is_dir;
+				return a.name < b.name;
+			});
+
+			// Draw rows
+			int idx = 0;
+			for (const auto &e: entries) {
+				ImGui::PushID(idx++); // ensure unique/stable IDs even if names repeat
+				std::string label;
+				label.reserve(e.name.size() + 4);
+				if (e.is_dir)
+					label += "[";
+				label += e.name;
+				if (e.is_dir)
+					label += "]";
+
+				// Render selectable row
+				ImGui::Selectable(label.c_str(), false, ImGuiSelectableFlags_AllowDoubleClick);
+
+				// Activate based strictly on hover + mouse, to avoid any off-by-one due to click routing
+				if (ImGui::IsItemHovered()) {
+					if (e.is_dir && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left)) {
+						// Enter directory on double-click
+						ed.SetFilePickerDir(e.path.string());
+					} else if (!e.is_dir && ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
+						// Open file on single click
+						std::string err;
+						if (!ed.OpenFile(e.path.string(), err)) {
+							ed.SetStatus(std::string("open: ") + err);
+						} else {
+							ed.SetStatus(std::string("Opened: ") + e.name);
+						}
+						ed.SetFilePickerVisible(false);
+					}
+				}
+				ImGui::PopID();
+			}
+
+			ImGui::EndChild();
+		}
+		ImGui::End();
+		if (!open) {
+			ed.SetFilePickerVisible(false);
+		}
+	}
 }
--- a/GUIRenderer.h
+++ b/GUIRenderer.h
@@ -6,7 +6,7 @@

 #include "Renderer.h"

-class GUIRenderer : public Renderer {
+class GUIRenderer final : public Renderer {
 public:
 	GUIRenderer() = default;

--- a/GUITheme.h
+++ b/GUITheme.h
--- a/GapBuffer.cc
+++ b/GapBuffer.cc
@@ -1,9 +1,10 @@
-#include "GapBuffer.h"
-
 #include <algorithm>
 #include <cassert>
 #include <cstring>

+#include "GapBuffer.h"
+
+
 GapBuffer::GapBuffer() = default;


--- a/GapBuffer.h
+++ b/GapBuffer.h
@@ -6,6 +6,7 @@

 #include <cstddef>

+
 class GapBuffer {
 public:
 	GapBuffer();
--- a/HelpText.cc
+++ b/HelpText.cc
@@ -0,0 +1,81 @@
+/*
+ * HelpText.cc - embedded/customizable help content
+ */
+
+#include "HelpText.h"
+
+
+std::string
+HelpText::Text()
+{
+	// Customize the help text here. This string will be used by C-k h first.
+	// You can keep it empty to fall back to the manpage or built-in defaults.
+	// Note: keep newline characters as-is; the renderer splits lines on '\n'.
+
+	return std::string(
+		"KTE - Kyle's Text Editor\n\n"
+		"About:\n"
+		"  kte is Kyle's Text Editor. It keeps a small, fast core and uses a\n"
+		"  WordStar/VDE-style command model with some emacs influences.\n"
+		"\n"
+		"K-commands (prefix C-k):\n"
+		"  C-k '        Toggle read-only\n"
+		"  C-k -        Unindent region (mark required)\n"
+		"  C-k =        Indent region (mark required)\n"
+		"  C-k ;        Command prompt (:\\ )\n"
+		"  C-k C-d      Kill entire line\n"
+		"  C-k C-q      Quit now (no confirm)\n"
+		"  C-k C-x      Save and quit\n"
+		"  C-k a        Mark start of file, jump to end\n"
+		"  C-k b        Switch buffer\n"
+		"  C-k c        Close current buffer\n"
+		"  C-k d        Kill to end of line\n"
+		"  C-k e        Open file (prompt)\n"
+		"  C-k f        Flush kill ring\n"
+		"  C-k g        Jump to line\n"
+		"  C-k h        Show this help\n"
+		"  C-k j        Jump to mark\n"
+		"  C-k l        Reload buffer from disk\n"
+		"  C-k n        Previous buffer\n"
+		"  C-k o        Change working directory (prompt)\n"
+		"  C-k p        Next buffer\n"
+		"  C-k q        Quit (confirm if dirty)\n"
+		"  C-k r        Redo\n"
+		"  C-k s        Save buffer\n"
+		"  C-k u        Undo\n"
+		"  C-k v        Toggle visual file picker (GUI)\n"
+		"  C-k w        Show working directory\n"
+		"  C-k x        Save and quit\n"
+		"  C-k y        Yank\n"
+		"\n"
+		"ESC/Alt commands:\n"
+		"  ESC <        Go to beginning of file\n"
+		"  ESC >        Go to end of file\n"
+		"  ESC m        Toggle mark\n"
+		"  ESC w        Copy region to kill ring (Alt-w)\n"
+		"  ESC b        Previous word\n"
+		"  ESC f        Next word\n"
+		"  ESC d        Delete next word (Alt-d)\n"
+		"  ESC BACKSPACE Delete previous word (Alt-Backspace)\n"
+		"  ESC q        Reflow paragraph\n"
+		"\n"
+		"Control keys:\n"
+		"  C-a C-e      Line start / end\n"
+		"  C-b C-f      Move left / right\n"
+		"  C-n C-p      Move down / up\n"
+		"  C-d          Delete char\n"
+		"  C-w / C-y    Kill region / Yank\n"
+		"  C-s          Incremental find\n"
+		"  C-r          Regex search\n"
+		"  C-t          Regex search & replace\n"
+		"  C-h          Search & replace\n"
+		"  C-l / C-g    Refresh / Cancel\n"
+		"  C-u [digits] Universal argument (repeat count)\n"
+		"\n"
+		"Buffers:\n  +HELP+ is read-only. Press C-k ' to toggle; C-k h restores it.\n"
+		"\n"
+		"GUI appearance (command prompt):\n"
+		"  : theme NAME         Set GUI theme (eink, gruvbox, nord, plan9, solarized)\n"
+		"  : background MODE    Set background: light | dark (affects eink, gruvbox, solarized)\n"
+	);
+}
--- a/HelpText.h
+++ b/HelpText.h
@@ -0,0 +1,17 @@
+/*
+ * HelpText.h - embedded/customizable help content
+ */
+#ifndef KTE_HELPTEXT_H
+#define KTE_HELPTEXT_H
+
+#include <string>
+
+class HelpText {
+public:
+	// Returns the embedded help text as a single string with newlines.
+	// Project maintainers can customize the returned string below
+	// (in HelpText.cc) without touching the help command logic.
+	static std::string Text();
+};
+
+#endif // KTE_HELPTEXT_H
--- a/InputHandler.h
+++ b/InputHandler.h
@@ -8,6 +8,7 @@

 #include "Command.h"

+
 // Result of translating raw input into an editor command.
 struct MappedInput {
 	bool hasCommand = false;
--- a/KKeymap.cc
+++ b/KKeymap.cc
@@ -1,9 +1,9 @@
-#include "KKeymap.h"
-
 #include <iostream>
 #include <ncurses.h>
 #include <ostream>

+#include "KKeymap.h"
+

 auto
 KLookupKCommand(const int ascii_key, const bool ctrl, CommandId &out) -> bool
@@ -33,6 +33,10 @@ KLookupKCommand(const int ascii_key, const bool ctrl, CommandId &out) -> bool
 		out = CommandId::Redo; // C-k r (redo)
 		return true;
 	}
+	if (ascii_key == '\'') {
+		out = CommandId::ToggleReadOnly; // C-k ' (toggle read-only)
+		return true;
+	}

 	switch (k_lower) {
 	case 'a':
@@ -59,6 +63,9 @@ KLookupKCommand(const int ascii_key, const bool ctrl, CommandId &out) -> bool
 	case 'g':
 		out = CommandId::JumpToLine;
 		return true;
+	case 'h':
+		out = CommandId::ShowHelp;
+		return true;
 	case 'j':
 		out = CommandId::JumpToMark;
 		return true;
@@ -83,6 +90,9 @@ KLookupKCommand(const int ascii_key, const bool ctrl, CommandId &out) -> bool
 	case 'u':
 		out = CommandId::Undo;
 		return true;
+	case 'v':
+		out = CommandId::VisualFilePickerToggle;
+		return true;
 	case 'w':
 		out = CommandId::ShowWorkingDirectory;
 		return true;
@@ -98,6 +108,9 @@ KLookupKCommand(const int ascii_key, const bool ctrl, CommandId &out) -> bool
 	case '=':
 		out = CommandId::IndentRegion;
 		return true;
+	case ';':
+		out = CommandId::CommandPromptStart; // C-k ; : generic command prompt
+		return true;
 	default:
 		break;
 	}
@@ -142,6 +155,15 @@ KLookupCtrlCommand(const int ascii_key, CommandId &out) -> bool
 	case 's':
 		out = CommandId::FindStart;
 		return true;
+	case 'r':
+		out = CommandId::RegexFindStart; // C-r regex search
+		return true;
+	case 't':
+		out = CommandId::RegexpReplace; // C-t regex search & replace
+		return true;
+	case 'h':
+		out = CommandId::SearchReplace; // C-h: search & replace
+		return true;
 	case 'l':
 		out = CommandId::Refresh;
 		return true;
--- a/KKeymap.h
+++ b/KKeymap.h
@@ -6,6 +6,7 @@

 #include "Command.h"

+
 // Lookup the command to execute after a C-k prefix.
 // Parameters:
 //  - ascii_key: ASCII code of the key, preferably lowercased if it's a letter.
--- a/PieceTable.h
+++ b/PieceTable.h
@@ -8,6 +8,7 @@
 #include <string>
 #include <vector>

+
 class PieceTable {
 public:
 	PieceTable();
--- a/README.md
+++ b/README.md
@@ -1,9 +1,11 @@
-kte — Kyle's Text Editor
+kte - Kyle's Text Editor
+
+![Editor screenshot](./docs/screenshot.jpg)

 Vision
 -------
-kte will be a small, fast, and understandable text editor with a
-terminal<EFBFBD>first UX and an optional ImGui GUI. It modernizes the
+kte is a small, fast, and understandable text editor with a
+terminal-first UX and an optional ImGui GUI. It modernizes the
 original ke editor while preserving its familiar WordStar/VDE‑style
 command model and Emacs‑influenced ergonomics. The focus is on
 simplicity of design, excellent latency, and pragmatic features you
@@ -11,7 +13,9 @@ can learn and keep in your head.

 I am experimenting with using Jetbrains Junie to assist in
 development, largely as a way to learn the effective use of agentic
-coding.
+coding. I worked with the agent by feeding it notes that I've been
+taking about text editors for the last few years, as well as the
+sources from the original ke editor that is all handwritten C.

 Project Goals
 -------------
@@ -26,89 +30,6 @@ Project Goals
  so a GUI can grow independently of the TUI.
 - Minimize dependencies; the GUI layer remains optional and isolated.

-User Experience (intended)
--------------------------
-
- Terminal first: instant startup, responsive editing, no surprises
-  over SSH.
- Optional GUI: an ImGui‑based window with tabs, menus, and
-  palette—sharing the same editor core and command model.
- Discoverable command model: WordStar/VDE style with a `C-k` prefix,
-  Emacs‑like incremental search, and context help.
- Sensible defaults with a simple config file for remaps and theme
-  selection.
- Respect the file system: no magic project files; autosave and
-  crash‑recovery journals are opt‑in and visible.
-
-Core Features (roadmapped)
--------------------------
-
- Buffers and windows
-    - Multiple file buffers; fast switching, closing, and reopening.
-    - Split views (horizontal/vertical) in TUI and tiled panels in
-      GUI.
- Editing primitives
-    - Gap buffer (primary) with an alternative piece table for
-      large‑edit scenarios.
-    - Kill/yank ring, word/sentence/paragraph motions, and rectangle
-      ops.
-    - Undo/redo with grouped edits and time‑travel scrubbing.
- Search and replace
-    - Incremental search (C-s) and regex search (C-r) with live
-      highlighting.
-    - Multi‑file grep with a quickfix list; replace with confirm.
- Files and projects
-    - Robust encoding/line‑ending detection; safe writes (atomic where
-      possible).
-    - File tree sidebar (GUI) and quick‑open palette.
-    - Lightweight session restore.
- Language niceties (opt‑in, no runtime servers required)
-    - Syntax highlighting via fast, table‑driven lexers.
-    - Basic indentation rules per language; trailing whitespace/EOF
-      newline helpers.
- Extensibility (later)
-    - Command palette actions backed by the core command model.
-    - Small C++ plugin ABI and a scripting shim for config‑time
-      customization.
-
-Interfaces
----------
-
- CLI: the primary interface. `kte [files]` starts in the terminal,
-  adopting your `$TERM` capabilities. Terminal mode is implemented
-  using ncurses.
- GUI: an optional ImGui‑based frontend that embeds the same editor
-  core.
-
-Architecture (intended)
-----------------------
-
- Core model
-    - Buffer: file I/O, cursor/mark, viewport state, and edit
-      operations.
-    - GapBuffer: fast in‑memory text structure for typical edits.
-    - PieceTable: alternative representation for heavy insert/delete
-      workflows.
- Controller layer
-    - InputHandler interface with `TerminalInputHandler` and
-      `GUIInputHandler` implementations.
-    - Command: normalized operations (save, kill, yank, move, search,
-      etc.).
- View layer
-    - Renderer interface with `TerminalRenderer` and `GUIRenderer`
-      implementations.
- Editor: top‑level state managing buffers, messaging, and global
-  flags.
-
-Performance and Reliability Targets
-----------------------------------
-
- Sub‑millisecond keystroke to screen update on typical files in TUI.
- Sustain fluid editing on multi‑megabyte files; graceful degradation
-  on very large files.
- Atomic/safe writes; autosave and crash‑recovery journals are
-  explicit and transparent.
-
 Keybindings
 -----------
 kte maintains ke’s command model while internals evolve. Highlights (subject to refinement):
@@ -137,26 +58,26 @@ Dependencies by platform
 ------------------------

 - macOS (Homebrew)
-  - Terminal (default):
-    - `brew install ncurses`
-  - Optional GUI (enable with `-DBUILD_GUI=ON`):
-    - `brew install sdl2 freetype`
-    - OpenGL is provided by the system framework on macOS; no package needed.
+    - Terminal (default):
+        - `brew install ncurses`
+    - Optional GUI (enable with `-DBUILD_GUI=ON`):
+        - `brew install sdl2 freetype`
+        - OpenGL is provided by the system framework on macOS; no package needed.

 - Debian/Ubuntu
-  - Terminal (default):
-    - `sudo apt-get install -y libncurses5-dev libncursesw5-dev`
-  - Optional GUI (enable with `-DBUILD_GUI=ON`):
-    - `sudo apt-get install -y libsdl2-dev libfreetype6-dev mesa-common-dev`
-    - The `mesa-common-dev` package provides OpenGL headers/libs (`libGL`).
+    - Terminal (default):
+        - `sudo apt-get install -y libncurses5-dev libncursesw5-dev`
+    - Optional GUI (enable with `-DBUILD_GUI=ON`):
+        - `sudo apt-get install -y libsdl2-dev libfreetype6-dev mesa-common-dev`
+        - The `mesa-common-dev` package provides OpenGL headers/libs (`libGL`).

 - NixOS/Nix
-  - Terminal (default):
-    - Ad-hoc shell: `nix-shell -p cmake gcc ncurses`
-  - Optional GUI (enable with `-DBUILD_GUI=ON`):
-    - Ad-hoc shell: `nix-shell -p cmake gcc ncurses SDL2 freetype libGL`
-  - With flakes/devshell (example `flake.nix` inputs not provided): include
-    `ncurses` for TUI, and `SDL2`, `freetype`, `libGL` for GUI in your devShell.
+    - Terminal (default):
+        - Ad-hoc shell: `nix-shell -p cmake gcc ncurses`
+    - Optional GUI (enable with `-DBUILD_GUI=ON`):
+        - Ad-hoc shell: `nix-shell -p cmake gcc ncurses SDL2 freetype libGL`
+    - With flakes/devshell (example `flake.nix` inputs not provided): include
+      `ncurses` for TUI, and `SDL2`, `freetype`, `libGL` for GUI in your devShell.

 Notes
 -----
@@ -180,6 +101,15 @@ Run:
 ./cmake-build-debug/kte [files]
 ```

+If you configured the GUI, you can also run the GUI-first target (when
+built as `kge`) or request the GUI from `kte`:
+
+```
+./cmake-build-debug/kte --gui [files]
+# or if built/installed as a separate GUI target
+./cmake-build-debug/kge [files]
+```
+
 GUI build example
 -----------------

@@ -194,30 +124,5 @@ cmake --build cmake-build-debug
 Status
 ------

- The project is under active evolution toward the above architecture
-  and UX. The terminal interface now uses ncurses for input and
-  rendering. GUI work will follow as a thin, optional layer. ke
-  compatibility remains a primary constraint while internals modernize.
-
-Roadmap (high level)
--------------------
-
-1. Solidify core buffer model (gap buffer), file I/O, and
-   ke‑compatible commands.
-2. Introduce structured undo/redo and search/replace with
-   highlighting.
-3. Stabilize terminal renderer and input handling across common
-   terminals. (initial ncurses implementation landed)
-4. Add piece table as an alternative backend with runtime selection
-   per buffer.
-5. Optional GUI frontend using ImGui; shared command palette.
-6. Language niceties (syntax highlighting, indentation rules) behind a
-   zero‑deps, fast path.
-7. Session restore, autosave/journaling, and safe write guarantees.
-8. Extensibility hooks with a small, stable API.
-References
----------
-
- [ke](https://git.wntrmute.dev/kyle/ke) manual and keybinding
-  reference: `ke.md`
- Inspirations: Antirez’ kilo, WordStar/VDE, Emacs, and `mg(1)`
+- This project is a hobby text editor meant to be my personal editor. I
+  do not warrant its suitability for anyone else.
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -1,116 +1,10 @@
-kte ROADMAP — from skeleton to a working editor
+ROADMAP / TODO:

-Scope for “working editor” v0.1
-
- Runs in a terminal; opens files passed on the CLI or an empty buffer.
- Basic navigation, insert/delete, newline handling.
- Status line and message area; shows filename, dirty flag, cursor position.
- Save file(s) to disk safely; quit/confirm on dirty buffers.
- Core ke key chords: C-g (cancel), C-k s/x/q/C-q, C-l, basic arrows, Enter/Backspace, C-s (simple find).
-
-Guiding principles
-
- Keep the core small and understandable; evolve incrementally.
- Separate model (Buffer/Editor), control (Input/Command), and view (Renderer).
- Favor terminal first; GUI hooks arrive later behind interfaces.
-
-✓ Milestone 0 — Wire up a minimal app shell
-
-1. main.cpp
-    - Replace demo printing with real startup using `Editor`.
-    - Parse CLI args; open each path into a buffer (create empty if none). ✓ when `kte file1 file2` loads buffers and
-      exits cleanly.
-2. Editor integration
-    - Ensure `Editor` can open/switch/close buffers and hold status messages.
-    - Add a temporary “headless loop” to prove open/save calls work.
-
-✓ Milestone 1 — Command model
-
-1. Command vocabulary
-    - Flesh out `Command.h/.cpp`: enums/struct for operations and data (e.g., InsertChar, MoveCursor, Save, Quit,
-      FindNext, etc.).
-    - Provide a dispatcher entry point callable from the input layer to mutate `Editor`/`Buffer`.
-    - Definition of done: commands exist for minimal edit/navigation/save/quit; no rendering yet.
-
-✓ Milestone 2 — Terminal input
-
-1. Input interfaces
-    - Add `InputHandler.h` interface plus `TerminalInputHandler` implementation.
-    - Terminal input via ncurses (`getch`, `keypad`, non‑blocking with `nodelay`), basic key decoding (arrows, Ctrl, ESC
-      sequences).
-2. Keymap
-    - Map ke chords to `Command` (C-k prefix handling, C-g cancel, C-l refresh, C-k s/x/q/C-q, C-s find start, text
-      input → InsertChar).
-3. Event loop
-    - Introduce the core loop in main: read key → translate to `Command` → dispatch → trigger render.
-
-✓ Milestone 3 — Terminal renderer
-
-1. View interfaces
-    - Add `Renderer.h` with `TerminalRenderer` implementation (ncurses‑based).
-2. Minimal draw
-    - Render viewport lines from current buffer; draw status bar (filename, dirty, row:col, message).
-    - Handle scrolling when cursor moves past edges; support window resize (SIGWINCH).
-3. Cursor
-    - Place terminal cursor at logical buffer location (account for tabs later; start with plain text).
-
-Milestone 4 — Buffer fundamentals to support editing
-
-1. GapBuffer
-    - Ensure `GapBuffer` supports insert char, backspace, delete, newline, and efficient cursor moves.
-2. Buffer API
-    - File I/O (open/save), dirty tracking, encoding/line ending kept simple (UTF‑8, LF) for v0.1.
-    - Cursor state, mark (optional later), and viewport bookkeeping.
-3. Basic motions
-    - Left/Right/Up/Down, Home/End, PageUp/PageDown; word f/b (optional in v0.1).
-
-Milestone 5 — Core editing loop complete
-
-1. Tighten loop timing
-    - Ensure keystroke→update→render latency is reliably low; avoid unnecessary redraws.
-2. Status/messages
-    - `Editor::SetStatus()` shows transient messages; C-l forces full refresh.
-3. Prompts
-    - Minimal prompt line for save‑as/confirm quit; blocking read in prompt mode is acceptable for v0.1.
-
-Milestone 6 — Search (minimal)
-
-1. Incremental search (C-s)
-    - Simple forward substring search with live highlight of current match; arrow keys navigate matches while in search
-      mode (ke‑style quirk acceptable).
-    - ESC/C-g exits search; Enter confirms and leaves cursor on match.
-
-Milestone 7 — Safety and polish for v0.1
-
-1. Safe writes
-    - Write to temp file then rename; preserve permissions where possible.
-2. Dirty/quit logic
-    - Confirm on quit when any buffer is dirty; `C-k C-q` bypasses confirmation.
-3. Resize/terminal quirks
-    - Handle small terminals gracefully; no crashes on narrow widths.
-4. Basic tests
-    - Unit tests for `GapBuffer`, Buffer open/save round‑trip, and command mapping.
-
-Out of scope for v0.1 (tracked, not blocking)
-
- Undo/redo, regex search, kill ring, word motions, tabs/render width, syntax highlighting, piece table selection, GUI.
-
-Implementation notes (files to add)
-
- Input: `InputHandler.h`, `TerminalInputHandler.cc/h` (ncurses).
- Rendering: `Renderer.h`, `TerminalRenderer.cc/h` (ncurses).
- Prompt helpers: minimal utility for line input in raw mode.
- Platform: small termios wrapper; SIGWINCH handler.
-
-Acceptance checklist for v0.1
-
- Start: `./kte [files]` opens files or an empty buffer.
- Edit: insert text, backspace, newlines; move cursor; content scrolls.
- Save: `C-k s` writes file atomically; dirty flag clears; status shows bytes written.
- Quit: `C-k q` confirms if dirty; `C-k C-q` exits without confirm; `C-k x` save+exit.
- Refresh: `C-l` redraws.
- Search: `C-s` finds next while typing; ESC cancels.
-
-Next concrete step
-
- Stabilize cursor placement and scrolling logic; add resize handling and begin minimal prompt for save‑as.
+- [x] Search + Replace
+- [x] Regex search + replace
+- [ ] The undo system should actually work
+- [x] Able to mark buffers as read-only
+- [x] Built-in help text
+- [x] Shorten paths in the homedir with ~
+- [x] When the filename is longer than the message window, scoot left to
+  keep it in view
--- a/TerminalFrontend.cc
+++ b/TerminalFrontend.cc
@@ -1,10 +1,10 @@
-#include <unistd.h>
-#include <termios.h>
 #include <ncurses.h>
+#include <termios.h>
+#include <unistd.h>

-#include "Editor.h"
-#include "Command.h"
 #include "TerminalFrontend.h"
+#include "Command.h"
+#include "Editor.h"


 bool
--- a/TerminalFrontend.h
+++ b/TerminalFrontend.h
@@ -4,10 +4,11 @@
 #ifndef KTE_TERMINAL_FRONTEND_H
 #define KTE_TERMINAL_FRONTEND_H

+#include <termios.h>
+
 #include "Frontend.h"
 #include "TerminalInputHandler.h"
 #include "TerminalRenderer.h"
-#include <termios.h>


 class TerminalFrontend final : public Frontend {
--- a/TerminalInputHandler.cc
+++ b/TerminalInputHandler.cc
@@ -1,8 +1,8 @@
-#include <ncurses.h>
 #include <cstdio>
+#include <ncurses.h>

-#include "KKeymap.h"
 #include "TerminalInputHandler.h"
+#include "KKeymap.h"

 namespace {
 constexpr int
--- a/TerminalInputHandler.h
+++ b/TerminalInputHandler.h
@@ -4,8 +4,6 @@
 #ifndef KTE_TERMINAL_INPUT_HANDLER_H
 #define KTE_TERMINAL_INPUT_HANDLER_H

-#include <cstdint>
-
 #include "InputHandler.h"


--- a/TerminalRenderer.cc
+++ b/TerminalRenderer.cc
@@ -1,19 +1,21 @@
-#include "TerminalRenderer.h"
-
-#include <ncurses.h>
-#include <cstdio>
-#include <string>
 #include <algorithm>
+#include <cstdio>
 #include <filesystem>
+#include <cstdlib>
+#include <ncurses.h>
+#include <regex>
+#include <string>

-#include "Editor.h"
+#include "TerminalRenderer.h"
 #include "Buffer.h"
+#include "Editor.h"

 // Version string expected to be provided by build system as KTE_VERSION_STR
 #ifndef KTE_VERSION_STR
 #  define KTE_VERSION_STR "dev"
 #endif

+
 TerminalRenderer::TerminalRenderer() = default;

 TerminalRenderer::~TerminalRenderer() = default;
@@ -41,18 +43,64 @@ TerminalRenderer::Draw(Editor &ed)
 		const int tabw = 8;
 		for (int r = 0; r < content_rows; ++r) {
 			move(r, 0);
-			std::size_t li = rowoffs + static_cast<std::size_t>(r);
+			std::size_t li         = rowoffs + static_cast<std::size_t>(r);
 			std::size_t render_col = 0;
-			std::size_t src_i = 0;
-			bool do_hl = ed.SearchActive() && li == ed.SearchMatchY() && ed.SearchMatchLen() > 0;
-			std::size_t mx = do_hl ? ed.SearchMatchX() : 0;
-			std::size_t mlen = do_hl ? ed.SearchMatchLen() : 0;
-			bool hl_on = false;
-			int written = 0;
+			std::size_t src_i      = 0;
+			// Compute matches for this line if search highlighting is active
+			bool search_mode = ed.SearchActive() && !ed.SearchQuery().empty();
+			std::vector<std::pair<std::size_t, std::size_t> > ranges; // [start, end)
+			if (search_mode && li < lines.size()) {
+				std::string sline = static_cast<std::string>(lines[li]);
+				// If regex search prompt is active (RegexSearch or RegexReplaceFind), use regex to compute highlight ranges
+				if (ed.PromptActive() && (
+					    ed.CurrentPromptKind() == Editor::PromptKind::RegexSearch || ed.
+					    CurrentPromptKind() == Editor::PromptKind::RegexReplaceFind)) {
+					try {
+						std::regex rx(ed.SearchQuery());
+						for (auto it = std::sregex_iterator(sline.begin(), sline.end(), rx);
+						     it != std::sregex_iterator(); ++it) {
+							const auto &m  = *it;
+							std::size_t sx = static_cast<std::size_t>(m.position());
+							std::size_t ex = sx + static_cast<std::size_t>(m.length());
+							ranges.emplace_back(sx, ex);
+						}
+					} catch (const std::regex_error &) {
+						// ignore invalid patterns here; status shows error
+					}
+				} else {
+					const std::string &q = ed.SearchQuery();
+					std::size_t pos      = 0;
+					while (!q.empty() && (pos = sline.find(q, pos)) != std::string::npos) {
+						ranges.emplace_back(pos, pos + q.size());
+						pos += q.size();
+					}
+				}
+			}
+			auto is_src_in_hl = [&](std::size_t si) -> bool {
+				if (ranges.empty())
+					return false;
+				// ranges are non-overlapping and ordered by construction
+				// linear scan is fine for now
+				for (const auto &rg: ranges) {
+					if (si < rg.first)
+						break;
+					if (si >= rg.first && si < rg.second)
+						return true;
+				}
+				return false;
+			};
+			// Track current-match to optionally emphasize
+			const bool has_current     = ed.SearchActive() && ed.SearchMatchLen() > 0;
+			const std::size_t cur_mx   = has_current ? ed.SearchMatchX() : 0;
+			const std::size_t cur_my   = has_current ? ed.SearchMatchY() : 0;
+			const std::size_t cur_mend = has_current ? (ed.SearchMatchX() + ed.SearchMatchLen()) : 0;
+			bool hl_on                 = false;
+			bool cur_on                = false;
+			int written                = 0;
 			if (li < lines.size()) {
-				const std::string &line = lines[li];
-				src_i                   = 0;
-				render_col              = 0;
+				std::string line = static_cast<std::string>(lines[li]);
+				src_i            = 0;
+				render_col       = 0;
 				while (written < cols) {
 					char ch       = ' ';
 					bool from_src = false;
@@ -75,16 +123,32 @@ TerminalRenderer::Draw(Editor &ed)
 							}
 							// Now render visible spaces
 							while (next_tab > 0 && written < cols) {
-								bool in_hl = do_hl && src_i >= mx && src_i < mx + mlen;
-								// highlight by source index
-								if (in_hl && !hl_on) {
+								bool in_hl  = search_mode && is_src_in_hl(src_i);
+								bool in_cur =
+									has_current && li == cur_my && src_i >= cur_mx
+									&& src_i < cur_mend;
+								// Toggle highlight attributes
+								int attr = 0;
+								if (in_hl)
+									attr |= A_STANDOUT;
+								if (in_cur)
+									attr |= A_BOLD;
+								if ((attr & A_STANDOUT) && !hl_on) {
 									attron(A_STANDOUT);
 									hl_on = true;
 								}
-								if (!in_hl && hl_on) {
+								if (!(attr & A_STANDOUT) && hl_on) {
 									attroff(A_STANDOUT);
 									hl_on = false;
 								}
+								if ((attr & A_BOLD) && !cur_on) {
+									attron(A_BOLD);
+									cur_on = true;
+								}
+								if (!(attr & A_BOLD) && cur_on) {
+									attroff(A_BOLD);
+									cur_on = false;
+								}
 								addch(' ');
 								++written;
 								++render_col;
@@ -107,16 +171,25 @@ TerminalRenderer::Draw(Editor &ed)
 						ch       = ' ';
 						from_src = false;
 					}
-					if (do_hl) {
-						bool in_hl = from_src && src_i >= mx && src_i < mx + mlen;
-						if (in_hl && !hl_on) {
-							attron(A_STANDOUT);
-							hl_on = true;
-						}
-						if (!in_hl && hl_on) {
-							attroff(A_STANDOUT);
-							hl_on = false;
-						}
+					bool in_hl  = search_mode && from_src && is_src_in_hl(src_i);
+					bool in_cur =
+						has_current && li == cur_my && from_src && src_i >= cur_mx && src_i <
+						cur_mend;
+					if (in_hl && !hl_on) {
+						attron(A_STANDOUT);
+						hl_on = true;
+					}
+					if (!in_hl && hl_on) {
+						attroff(A_STANDOUT);
+						hl_on = false;
+					}
+					if (in_cur && !cur_on) {
+						attron(A_BOLD);
+						cur_on = true;
+					}
+					if (!in_cur && cur_on) {
+						attroff(A_BOLD);
+						cur_on = false;
 					}
 					addch(static_cast<unsigned char>(ch));
 					++written;
@@ -131,6 +204,10 @@ TerminalRenderer::Draw(Editor &ed)
 				attroff(A_STANDOUT);
 				hl_on = false;
 			}
+			if (cur_on) {
+				attroff(A_BOLD);
+				cur_on = false;
+			}
 			clrtoeol();
 		}

@@ -149,7 +226,7 @@ TerminalRenderer::Draw(Editor &ed)
 		mvaddstr(0, 0, "[no buffer]");
 	}

-	// Status line (inverse) — left: app/version/buffer/dirty, middle: message, right: cursor/mark
+	// Status line (inverse)
 	move(rows - 1, 0);
 	attron(A_REVERSE);

@@ -157,6 +234,67 @@ TerminalRenderer::Draw(Editor &ed)
 	for (int i = 0; i < cols; ++i)
 		addch(' ');

+	// If a prompt is active, replace the status bar with the full prompt text
+	if (ed.PromptActive()) {
+		// Build prompt text: "Label: text" and shorten HOME path for file-related prompts
+		std::string label = ed.PromptLabel();
+		std::string ptext = ed.PromptText();
+		auto kind         = ed.CurrentPromptKind();
+		if (kind == Editor::PromptKind::OpenFile || kind == Editor::PromptKind::SaveAs ||
+		    kind == Editor::PromptKind::Chdir) {
+			const char *home_c = std::getenv("HOME");
+			if (home_c && *home_c) {
+				std::string home(home_c);
+				// Ensure we match only at the start
+				if (ptext.rfind(home, 0) == 0) {
+					std::string rest = ptext.substr(home.size());
+					if (rest.empty())
+						ptext = "~";
+					else if (rest[0] == '/' || rest[0] == '\\')
+						ptext = std::string("~") + rest;
+				}
+			}
+		}
+		// Prefer keeping the tail of the filename visible when it exceeds the window
+		std::string msg;
+		if (kind == Editor::PromptKind::Command) {
+			msg = ": ";
+		} else if (!label.empty()) {
+			msg = label + ": ";
+		}
+		// When dealing with file-related prompts, left-trim the filename text so the tail stays visible
+		if ((kind == Editor::PromptKind::OpenFile || kind == Editor::PromptKind::SaveAs || kind ==
+		     Editor::PromptKind::Chdir) && cols > 0) {
+			int avail = cols - static_cast<int>(msg.size());
+			if (avail <= 0) {
+				// No room for label; fall back to showing the rightmost portion of the whole string
+				std::string whole = msg + ptext;
+				if ((int) whole.size() > cols)
+					whole = whole.substr(whole.size() - cols);
+				msg = whole;
+			} else {
+				if ((int) ptext.size() > avail) {
+					ptext = ptext.substr(ptext.size() - avail);
+				}
+				msg += ptext;
+			}
+		} else {
+			// Non-file prompts: simple concatenation and clip by terminal
+			msg += ptext;
+		}
+
+		// Draw left-aligned, clipped to width
+		if (!msg.empty())
+			mvaddnstr(rows - 1, 0, msg.c_str(), std::max(0, cols));
+
+		// End status rendering for prompt mode
+		attroff(A_REVERSE);
+		// Restore logical cursor position in content area
+		if (saved_cur_y >= 0 && saved_cur_x >= 0)
+			move(saved_cur_y, saved_cur_x);
+		return;
+	}
+
 	// Build left segment
 	std::string left;
 	{
@@ -180,9 +318,24 @@ TerminalRenderer::Draw(Editor &ed)
 			fname = "[no name]";
 		}
 		left += "  ";
+		// Insert buffer position prefix "[x/N] " before filename
+		{
+			std::size_t total = ed.BufferCount();
+			if (total > 0) {
+				std::size_t idx1 = ed.CurrentBufferIndex() + 1; // human-friendly 1-based
+				left += "[";
+				left += std::to_string(static_cast<unsigned long long>(idx1));
+				left += "/";
+				left += std::to_string(static_cast<unsigned long long>(total));
+				left += "] ";
+			}
+		}
 		left += fname;
 		if (b && b->Dirty())
 			left += " *";
+		// Append read-only indicator
+		if (b && b->IsReadOnly())
+			left += " [RO]";
 		// Append total line count as "<n>L"
 		if (b) {
 			unsigned long lcount = static_cast<unsigned long>(b->Rows().size());
--- a/TestFrontend.cc
+++ b/TestFrontend.cc
@@ -1,7 +1,6 @@
 #include "TestFrontend.h"
-#include "Editor.h"
 #include "Command.h"
-#include <iostream>
+#include "Editor.h"


 bool
--- a/TestInputHandler.h
+++ b/TestInputHandler.h
@@ -4,11 +4,12 @@
 #ifndef KTE_TEST_INPUT_HANDLER_H
 #define KTE_TEST_INPUT_HANDLER_H

-#include "InputHandler.h"
 #include <queue>

+#include "InputHandler.h"

-class TestInputHandler : public InputHandler {
+
+class TestInputHandler final : public InputHandler {
 public:
 	TestInputHandler() = default;

@@ -21,7 +22,7 @@ public:
 	void QueueText(const std::string &text);


-	bool IsEmpty() const
+	[[nodiscard]] bool IsEmpty() const
 	{
 		return queue_.empty();
 	}
--- a/TestRenderer.cc
+++ b/TestRenderer.cc
@@ -1,5 +1,4 @@
 #include "TestRenderer.h"
-#include "Editor.h"


 void
--- a/TestRenderer.h
+++ b/TestRenderer.h
@@ -4,11 +4,12 @@
 #ifndef KTE_TEST_RENDERER_H
 #define KTE_TEST_RENDERER_H

-#include "Renderer.h"
 #include <cstddef>

+#include "Renderer.h"

-class TestRenderer : public Renderer {
+
+class TestRenderer final : public Renderer {
 public:
 	TestRenderer() = default;

@@ -17,7 +18,7 @@ public:
 	void Draw(Editor &ed) override;


-	std::size_t GetDrawCount() const
+	[[nodiscard]] std::size_t GetDrawCount() const
 	{
 		return draw_count_;
 	}
--- a/UndoNode.h
+++ b/UndoNode.h
@@ -1,12 +1,11 @@
 #ifndef KTE_UNDONODE_H
 #define KTE_UNDONODE_H

-#include <cstddef>
 #include <cstdint>
 #include <string>


-enum class UndoType : uint8_t {
+enum class UndoType : std::uint8_t {
 	Insert,
 	Delete,
 	Paste,
--- a/UndoSystem.cc
+++ b/UndoSystem.cc
@@ -1,5 +1,7 @@
 #include "UndoSystem.h"
 #include "Buffer.h"
+#include <cassert>
+#include <cstdio>


 UndoSystem::UndoSystem(Buffer &owner, UndoTree &tree)
@@ -9,21 +11,24 @@ UndoSystem::UndoSystem(Buffer &owner, UndoTree &tree)
 void
 UndoSystem::Begin(UndoType type)
 {
+#ifdef KTE_UNDO_DEBUG
+	debug_log("Begin");
+#endif
 	// Reuse pending if batching conditions are met
 	const int row = static_cast<int>(buf_->Cury());
 	const int col = static_cast<int>(buf_->Curx());
 	if (tree_.pending && tree_.pending->type == type && tree_.pending->row == row) {
 		if (type == UndoType::Delete) {
 			// Support batching both forward deletes (DeleteChar) and backspace (prepend case)
-			// Forward delete: cursor stays at anchor col; expected == col
-			std::size_t anchor = static_cast<std::size_t>(tree_.pending->col);
-			if (anchor + tree_.pending->text.size() == static_cast<std::size_t>(col)) {
+			// Forward delete: cursor stays at anchor col; keep batching when col == anchor
+			const auto anchor = static_cast<std::size_t>(tree_.pending->col);
+			if (anchor == static_cast<std::size_t>(col)) {
 				pending_prepend_ = false;
 				return; // keep batching forward delete
 			}
-			// Backspace: cursor moved left by 1; allow extend if col + text.size() == anchor
-			if (static_cast<std::size_t>(col) + tree_.pending->text.size() == anchor) {
-				// Move anchor one left to new cursor column; next Append should prepend
+			// Backspace: cursor moved left by exactly one position relative to current anchor.
+			// Extend batch by shifting anchor left and prepending the deleted byte.
+			if (static_cast<std::size_t>(col) + 1 == anchor) {
 				tree_.pending->col = col;
 				pending_prepend_   = true;
 				return;
@@ -47,6 +52,16 @@ UndoSystem::Begin(UndoType type)
 	node->next       = nullptr;
 	tree_.pending    = node;
 	pending_prepend_ = false;
+
+#ifdef KTE_UNDO_DEBUG
+	debug_log("Begin:new");
+#endif
+	// Assert pending is detached from the tree
+	assert(tree_.pending && "pending must exist after Begin");
+	assert(tree_.pending != tree_.root);
+	assert(tree_.pending != tree_.current);
+	assert(tree_.pending != tree_.saved);
+	assert(!is_descendant(tree_.root, tree_.pending));
 }


@@ -61,6 +76,9 @@ UndoSystem::Append(char ch)
 	} else {
 		tree_.pending->text.push_back(ch);
 	}
+#ifdef KTE_UNDO_DEBUG
+	debug_log("Append:ch");
+#endif
 }


@@ -70,12 +88,18 @@ UndoSystem::Append(std::string_view text)
 	if (!tree_.pending)
 		return;
 	tree_.pending->text.append(text.data(), text.size());
+#ifdef KTE_UNDO_DEBUG
+	debug_log("Append:sv");
+#endif
 }


 void
 UndoSystem::commit()
 {
+#ifdef KTE_UNDO_DEBUG
+	debug_log("commit:enter");
+#endif
 	if (!tree_.pending)
 		return;

@@ -105,6 +129,11 @@ UndoSystem::commit()
 	}
 	tree_.pending = nullptr;
 	update_dirty_flag();
+#ifdef KTE_UNDO_DEBUG
+	debug_log("commit:done");
+#endif
+	// post-conditions
+	assert(tree_.pending == nullptr && "pending must be cleared after commit");
 }


@@ -121,6 +150,9 @@ UndoSystem::undo()
 	apply(node, -1);
 	tree_.current = parent;
 	update_dirty_flag();
+#ifdef KTE_UNDO_DEBUG
+	debug_log("undo");
+#endif
 }


@@ -143,6 +175,9 @@ UndoSystem::redo()
 	apply(next, +1);
 	tree_.current = next;
 	update_dirty_flag();
+#ifdef KTE_UNDO_DEBUG
+	debug_log("redo");
+#endif
 }


@@ -151,6 +186,9 @@ UndoSystem::mark_saved()
 {
 	tree_.saved = tree_.current;
 	update_dirty_flag();
+#ifdef KTE_UNDO_DEBUG
+	debug_log("mark_saved");
+#endif
 }


@@ -161,6 +199,9 @@ UndoSystem::discard_pending()
 		delete tree_.pending;
 		tree_.pending = nullptr;
 	}
+#ifdef KTE_UNDO_DEBUG
+	debug_log("discard_pending");
+#endif
 }


@@ -175,6 +216,9 @@ UndoSystem::clear()
 	}
 	tree_.root = tree_.current = tree_.saved = tree_.pending = nullptr;
 	update_dirty_flag();
+#ifdef KTE_UNDO_DEBUG
+	debug_log("clear");
+#endif
 }


@@ -293,3 +337,62 @@ UndoSystem::UpdateBufferReference(Buffer &new_buf)
 {
 	buf_ = &new_buf;
 }
+
+
+// ---- Debug helpers ----
+const char *
+UndoSystem::type_str(UndoType t)
+{
+	switch (t) {
+	case UndoType::Insert:
+		return "Insert";
+	case UndoType::Delete:
+		return "Delete";
+	case UndoType::Paste:
+		return "Paste";
+	case UndoType::Newline:
+		return "Newline";
+	case UndoType::DeleteRow:
+		return "DeleteRow";
+	}
+	return "?";
+}
+
+
+bool
+UndoSystem::is_descendant(UndoNode *root, const UndoNode *target)
+{
+	if (!root || !target)
+		return false;
+	if (root == target)
+		return true;
+	for (UndoNode *child = root->child; child != nullptr; child = child->next) {
+		if (is_descendant(child, target))
+			return true;
+	}
+	return false;
+}
+
+
+void
+UndoSystem::debug_log(const char *op) const
+{
+#ifdef KTE_UNDO_DEBUG
+	int row           = static_cast<int>(buf_->Cury());
+	int col           = static_cast<int>(buf_->Curx());
+	const UndoNode *p = tree_.pending;
+	std::fprintf(stderr,
+	             "[UNDO] %s cur=(%d,%d) pending=%p t=%s r=%d c=%d nlen=%zu current=%p saved=%p\n",
+	             op,
+	             row, col,
+	             (const void *) p,
+	             p ? type_str(p->type) : "-",
+	             p ? p->row : -1,
+	             p ? p->col : -1,
+	             p ? p->text.size() : 0,
+	             (void *) tree_.current,
+	             (void *) tree_.saved);
+#else
+	(void) op;
+#endif
+}
--- a/UndoSystem.h
+++ b/UndoSystem.h
@@ -2,8 +2,12 @@
 #define KTE_UNDOSYSTEM_H

 #include <string_view>
+#include <cstddef>
+#include <cstdint>
+
 #include "UndoTree.h"

+
 class Buffer;

 class UndoSystem {
@@ -37,9 +41,15 @@ private:
 	void free_branch(UndoNode *node); // frees redo siblings only
 	UndoNode *find_parent(UndoNode *from, UndoNode *target);

+	// Debug helpers (compiled only when KTE_UNDO_DEBUG is defined)
+	void debug_log(const char *op) const;
+
+	static const char *type_str(UndoType t);
+
+	static bool is_descendant(UndoNode *root, const UndoNode *target);
+
 	void update_dirty_flag();

-private:
 	Buffer *buf_;
 	UndoTree &tree_;
 	// Internal hint for Delete batching: whether next Append() should prepend
--- a/UndoTree.h
+++ b/UndoTree.h
@@ -2,7 +2,7 @@
 #define KTE_UNDOTREE_H

 #include "UndoNode.h"
-#include <memory>
+

 struct UndoTree {
 	UndoNode *root    = nullptr; // first edit ever
--- a/cmake/Info.plist.in
+++ b/cmake/Info.plist.in
@@ -6,6 +6,8 @@
    <string>en</string>
    <key>CFBundleExecutable</key>
    <string>kge</string>
+    <key>CFBundleIconFile</key>
+    <string>@MACOSX_BUNDLE_ICON_FILE@</string>
    <key>CFBundleIdentifier</key>
    <string>@KGE_BUNDLE_ID@</string>
    <key>CFBundleInfoDictionaryVersion</key>
@@ -23,4 +25,4 @@
    <key>NSHighResolutionCapable</key>
    <true/>
 </dict>
-</plist>
+</plist>
--- a/default-gui.nix
+++ b/default-gui.nix
@@ -1,51 +0,0 @@
-{
-  lib,
-  stdenv,
-  cmake,
-  ncurses,
-  SDL2,
-  libGL,
-  xorg,
-  installShellFiles,
-  ...
-}:
-let
-  cmakeContent = builtins.readFile ./CMakeLists.txt;
-  cmakeLines = lib.splitString "\n" cmakeContent;
-  versionLine = lib.findFirst (l: builtins.match ".*set\\(KTE_VERSION \".+\"\\).*" l != null) (throw "KTE_VERSION not found in CMakeLists.txt") cmakeLines;
-  version = builtins.head (builtins.match ".*set\\(KTE_VERSION \"(.+)\"\\).*" versionLine);
-in
-stdenv.mkDerivation {
-  pname = "kte";
-  inherit version;
-
-  src = lib.cleanSource ./.;
-
-  nativeBuildInputs = [
-    cmake
-    ncurses
-    SDL2
-    libGL
-    xorg.libX11
-    installShellFiles
-  ];
-
-  cmakeFlags = [
-    "-DBUILD_GUI=ON"
-    "-DCMAKE_BUILD_TYPE=Debug"
-  ];
-
-  installPhase = ''
-    runHook preInstall
-
-    mkdir -p $out/bin
-    cp kte $out/bin/
-    cp kge $out/bin/
-
-    installManPage ../docs/kte.1
-    installManPage ../docs/kge.1
-
-
-    runHook postInstall
-  '';
-}
--- a/default-nogui.nix
+++ b/default-nogui.nix
@@ -1,42 +0,0 @@
-{
-  lib,
-  stdenv,
-  cmake,
-  ncurses,
-  installShellFiles,
-  ...
-}:
-let
-  cmakeContent = builtins.readFile ./CMakeLists.txt;
-  cmakeLines = lib.splitString "\n" cmakeContent;
-  versionLine = lib.findFirst (l: builtins.match ".*set\\(KTE_VERSION \".+\"\\).*" l != null) (throw "KTE_VERSION not found in CMakeLists.txt") cmakeLines;
-  version = builtins.head (builtins.match ".*set\\(KTE_VERSION \"(.+)\"\\).*" versionLine);
-in
-stdenv.mkDerivation {
-  pname = "kte";
-  inherit version;
-
-  src = lib.cleanSource ./.;
-
-  nativeBuildInputs = [
-    cmake
-    ncurses
-    installShellFiles
-  ];
-
-  cmakeFlags = [
-    "-DBUILD_GUI=OFF"
-    "-DCMAKE_BUILD_TYPE=Debug"
-  ];
-
-  installPhase = ''
-    runHook preInstall
-
-    mkdir -p $out/bin
-    cp kte $out/bin/
-
-    installManPage ../docs/kte.1
-
-    runHook postInstall
-  '';
-}
--- a/default.nix
+++ b/default.nix
@@ -7,12 +7,16 @@
  libGL,
  xorg,
  installShellFiles,
+
+  graphical ? false,
  ...
 }:
 let
  cmakeContent = builtins.readFile ./CMakeLists.txt;
  cmakeLines = lib.splitString "\n" cmakeContent;
-  versionLine = lib.findFirst (l: builtins.match ".*set\\(KTE_VERSION \".+\"\\).*" l != null) (throw "KTE_VERSION not found in CMakeLists.txt") cmakeLines;
+  versionLine = lib.findFirst (
+    l: builtins.match ".*set\\(KTE_VERSION \".+\"\\).*" l != null
+  ) (throw "KTE_VERSION not found in CMakeLists.txt") cmakeLines;
  version = builtins.head (builtins.match ".*set\\(KTE_VERSION \"(.+)\"\\).*" versionLine);
 in
 stdenv.mkDerivation {
@@ -24,14 +28,16 @@ stdenv.mkDerivation {
  nativeBuildInputs = [
    cmake
    ncurses
+    installShellFiles
+  ]
+  ++ lib.optionals graphical [
    SDL2
    libGL
    xorg.libX11
-    installShellFiles
  ];

  cmakeFlags = [
-    "-DBUILD_GUI=ON"
+    "-DBUILD_GUI=${if graphical then "ON" else "OFF"}"
    "-DCMAKE_BUILD_TYPE=Debug"
  ];

@@ -40,11 +46,17 @@ stdenv.mkDerivation {

    mkdir -p $out/bin
    cp kte $out/bin/
-    cp kge $out/bin/

    installManPage ../docs/kte.1
-    installManPage ../docs/kge.1

+  ''
+  + lib.optionalString graphical ''
+    cp kge $out/bin/
+    installManPage ../docs/kge.1
+    mkdir -p $out/share/icons
+    cp ../kge.png $out/share/icons/
+  ''
+  + ''
    runHook postInstall
  '';
 }
--- a/docs/kge.1
+++ b/docs/kge.1
@@ -1,7 +1,7 @@
 .\" kge(1) — Kyle's Graphical Editor (GUI-first)
 .\"
 .\" Project homepage: https://github.com/wntrmute/kte
-.TH KGE 1 "2025-11-30" "kte 0.1.0" "User Commands"
+.TH KGE 1 "2025-12-01" "kte 0.1.0" "User Commands"
 .SH NAME
 kge \- Kyle's Graphical Editor (GUI-first)
 .SH SYNOPSIS
@@ -17,8 +17,11 @@ kge \- Kyle's Graphical Editor (GUI-first)
 is the GUI-first build target of Kyle's Text Editor. It shares the same
 editor core and command model as
 .BR kte (1),
-but defaults to the graphical ImGui frontend when available. A terminal
-(ncurses) frontend is also available and can be requested explicitly.
+and defaults to the graphical ImGui frontend when available. A terminal
+(ncurses) frontend is also available and can be requested explicitly with
+.B --term
+or by invoking
+.BR kte (1).

 If one or more
 .I files
@@ -49,11 +52,8 @@ tree for the canonical reference and notes:
 .PP
 Enter K-command mode with Ctrl-K. Exit K-command mode with ESC or Ctrl-G.
 .TP
-.B C-k BACKSPACE
-Delete from the cursor to the beginning of the line.
-.TP
-.B C-k SPACE
-Toggle the mark.
+.B C-k '
+Toggle read-only for the current buffer.
 .TP
 .B C-k -
 If the mark is set, unindent the region.
@@ -61,6 +61,9 @@ If the mark is set, unindent the region.
 .B C-k =
 If the mark is set, indent the region.
 .TP
+.B C-k ;
+Open the generic command prompt (": ").
+.TP
 .B C-k a
 Set the mark at the beginning of the file, then jump to the end of the file.
 .TP
@@ -77,7 +80,7 @@ Delete from the cursor to the end of the line.
 Delete the entire line.
 .TP
 .B C-k e
-Edit a new file.
+Edit (open) a new file.
 .TP
 .B C-k f
 Flush the kill ring.
@@ -85,14 +88,20 @@ Flush the kill ring.
 .B C-k g
 Go to a specific line.
 .TP
+.B C-k h
+Show the built-in help (+HELP+ buffer).
+.TP
 .B C-k j
 Jump to the mark.
 .TP
 .B C-k l
 Reload the current buffer from disk.
 .TP
-.B C-k m
-Run make(1), reporting success or failure.
+.B C-k n
+Switch to the previous buffer.
+.TP
+.B C-k o
+Change working directory (prompt).
 .TP
 .B C-k p
 Switch to the next buffer.
@@ -103,14 +112,20 @@ Exit the editor. If the file has unsaved changes, a warning will be printed; a s
 .B C-k C-q
 Immediately exit the editor.
 .TP
+.B C-k r
+Redo changes.
+.TP
 .B C-k s
 Save the file, prompting for a filename if needed.
 .TP
 .B C-k u
 Undo.
 .TP
-.B C-k r
-Redo changes.
+.B C-k v
+Toggle visual file picker (GUI).
+.TP
+.B C-k w
+Show the current working directory.
 .TP
 .B C-k x
 Save the file and exit. Also C-k C-x.
@@ -118,23 +133,50 @@ Save the file and exit. Also C-k C-x.
 .B C-k y
 Yank the kill ring.
 .TP
-.B C-k \e
-Dump core.
+.B C-k C-x
+Save the file and exit.

 .SS Other keybindings
 .TP
 .B C-g
 Cancel the current operation.
 .TP
+.B C-a
+Move to the beginning of the line.
+.TP
+.B C-e
+Move to the end of the line.
+.TP
+.B C-b
+Move left.
+.TP
+.B C-f
+Move right.
+.TP
+.B C-n
+Move down.
+.TP
+.B C-p
+Move up.
+.TP
 .B C-l
 Refresh the display.
 .TP
+.B C-d
+Delete the character at the cursor.
+.TP
 .B C-r
 Regex search.
 .TP
 .B C-s
 Incremental find.
 .TP
+.B C-t
+Regex search and replace.
+.TP
+.B C-h
+Search and replace.
+.TP
 .B C-u
 Universal argument. C-u followed by numbers will repeat an operation n times.
 .TP
@@ -144,6 +186,15 @@ Kill the region if the mark is set.
 .B C-y
 Yank the kill ring.
 .TP
+.B ESC <
+Move to the beginning of the file.
+.TP
+.B ESC >
+Move to the end of the file.
+.TP
+.B ESC m
+Toggle the mark.
+.TP
 .B ESC BACKSPACE
 Delete the previous word.
 .TP
@@ -199,6 +250,8 @@ Open using the terminal frontend from kge:
 .BR kte (1),
 .I docs/ke.md
 (project keybinding manual)
+.br
+Project homepage: https://github.com/wntrmute/kte
 .SH BUGS
 Report issues on the project tracker. Some behaviors are inherited from
 ke and may evolve over time; see the manual for notes.
--- a/docs/kte.1
+++ b/docs/kte.1
@@ -1,7 +1,7 @@
 .\" kte(1) — Kyle's Text Editor (terminal-first)
 .\"
 .\" Project homepage: https://github.com/wntrmute/kte
-.TH KTE 1 "2025-11-30" "kte 0.1.0" "User Commands"
+.TH KTE 1 "2025-12-01" "kte 0.1.0" "User Commands"
 .SH NAME
 kte \- Kyle's Text Editor (terminal-first)
 .SH SYNOPSIS
@@ -16,8 +16,15 @@ kte \- Kyle's Text Editor (terminal-first)
 .B kte
 is a small, fast, and understandable text editor with a terminal-first
 experience. It preserves ke's WordStar/VDE-style command model with
-Emacs-influenced ergonomics. The core uses ncurses in the terminal and can
-optionally run with a GUI frontend if built.
+Emacs-influenced ergonomics. The core uses ncurses in the terminal.
+
+By default, .B kte
+runs in the terminal (ncurses) frontend. If the binary was built with GUI
+support, the same editor core can be shown with an ImGui-based GUI by passing
+.B --gui
+or by invoking the GUI-first target
+.BR kge (1)
+when available.

 If one or more
 .I files
@@ -50,11 +57,8 @@ in the source tree for the canonical reference and notes.
 .PP
 Enter K-command mode with Ctrl-K. Exit K-command mode with ESC or Ctrl-G.
 .TP
-.B C-k BACKSPACE
-Delete from the cursor to the beginning of the line.
-.TP
-.B C-k SPACE
-Toggle the mark.
+.B C-k '
+Toggle read-only for the current buffer.
 .TP
 .B C-k -
 If the mark is set, unindent the region.
@@ -62,6 +66,9 @@ If the mark is set, unindent the region.
 .B C-k =
 If the mark is set, indent the region.
 .TP
+.B C-k ;
+Open the generic command prompt (": ").
+.TP
 .B C-k a
 Set the mark at the beginning of the file, then jump to the end of the file.
 .TP
@@ -78,7 +85,7 @@ Delete from the cursor to the end of the line.
 Delete the entire line.
 .TP
 .B C-k e
-Edit a new file.
+Edit (open) a new file.
 .TP
 .B C-k f
 Flush the kill ring.
@@ -86,14 +93,20 @@ Flush the kill ring.
 .B C-k g
 Go to a specific line.
 .TP
+.B C-k h
+Show the built-in help (+HELP+ buffer).
+.TP
 .B C-k j
 Jump to the mark.
 .TP
 .B C-k l
 Reload the current buffer from disk.
 .TP
-.B C-k m
-Run make(1), reporting success or failure.
+.B C-k n
+Switch to the previous buffer.
+.TP
+.B C-k o
+Change working directory (prompt).
 .TP
 .B C-k p
 Switch to the next buffer.
@@ -104,14 +117,20 @@ Exit the editor. If the file has unsaved changes, a warning will be printed; a s
 .B C-k C-q
 Immediately exit the editor.
 .TP
+.B C-k r
+Redo changes.
+.TP
 .B C-k s
 Save the file, prompting for a filename if needed.
 .TP
 .B C-k u
 Undo.
 .TP
-.B C-k r
-Redo changes.
+.B C-k v
+Toggle visual file picker (GUI).
+.TP
+.B C-k w
+Show the current working directory.
 .TP
 .B C-k x
 Save the file and exit. Also C-k C-x.
@@ -119,23 +138,76 @@ Save the file and exit. Also C-k C-x.
 .B C-k y
 Yank the kill ring.
 .TP
-.B C-k \e
-Dump core.
+.B C-k C-x
+Save the file and exit.
+
+.SH GUI APPEARANCE
+When running the GUI frontend, you can control appearance via the generic
+command prompt (type "C-k ;" then enter commands):
+.TP
+.B : theme NAME
+Set the GUI theme. Available names: "nord", "gruvbox", "plan9", "solarized", "eink".
+Compatibility aliases are also accepted: "gruvbox-dark", "gruvbox-light",
+"solarized-dark", "solarized-light", "eink-dark", "eink-light".
+.TP
+.B : background MODE
+Set background mode for supported themes. MODE is either "light" or "dark".
+Themes that respond to background: eink, gruvbox, solarized. The
+"nord" and "plan9" themes do not vary with background.
+
+.SH CONFIGURATION
+The GUI reads a simple configuration file at
+~/.config/kte/kge.ini. Recognized keys include:
+.IP "fullscreen=on|off"
+.IP "columns=NUM"
+.IP "rows=NUM"
+.IP "font_size=NUM"
+.IP "theme=NAME"
+.IP "background=light|dark"
+The theme name accepts the values listed above. The background key controls
+light/dark variants when the selected theme supports it.

 .SS Other keybindings
 .TP
 .B C-g
 Cancel the current operation.
 .TP
+.B C-a
+Move to the beginning of the line.
+.TP
+.B C-e
+Move to the end of the line.
+.TP
+.B C-b
+Move left.
+.TP
+.B C-f
+Move right.
+.TP
+.B C-n
+Move down.
+.TP
+.B C-p
+Move up.
+.TP
 .B C-l
 Refresh the display.
 .TP
+.B C-d
+Delete the character at the cursor.
+.TP
 .B C-r
 Regex search.
 .TP
 .B C-s
 Incremental find.
 .TP
+.B C-t
+Regex search and replace.
+.TP
+.B C-h
+Search and replace.
+.TP
 .B C-u
 Universal argument. C-u followed by numbers will repeat an operation n times.
 .TP
@@ -145,6 +217,15 @@ Kill the region if the mark is set.
 .B C-y
 Yank the kill ring.
 .TP
+.B ESC <
+Move to the beginning of the file.
+.TP
+.B ESC >
+Move to the end of the file.
+.TP
+.B ESC m
+Toggle the mark.
+.TP
 .B ESC BACKSPACE
 Delete the previous word.
 .TP
@@ -194,6 +275,8 @@ Force GUI frontend (if available):
 .BR kge (1),
 .I docs/ke.md
 (project keybinding manual)
+.br
+Project homepage: https://github.com/wntrmute/kte
 .SH BUGS
 Incremental search currently restarts from the top on each invocation; see
 \(lqKnown behavior\(rq in the ke manual. Report issues on the project tracker.
--- a/docs/screenshot.jpg
+++ b/docs/screenshot.jpg
--- a/docs/syntax
+++ b/docs/syntax
@@ -0,0 +1,102 @@
+### Objective
+Introduce fast, minimal‑dependency syntax highlighting to kte, consistent with current architecture (Editor/Buffer + GUI/Terminal renderers), preserving ke UX and performance.
+
+### Guiding principles
+- Keep core small and fast; no heavy deps (C++17 only). 
+- Start simple (stateless line regex), evolve incrementally (stateful, caching). 
+- Work in both Terminal (ncurses) and GUI (ImGui) with consistent token classes and theme mapping. 
+- Integrate without disrupting existing search highlight, selection, or cursor rendering.
+
+### Scope of v1
+- Languages: plain text (off), C/C++ minimal set (keywords, types, strings, chars, comments, numbers, preprocessor). 
+- Stateless per‑line highlighting; handle single‑line comments and strings; defer multi‑line state to v2. 
+- Toggle: `:syntax on|off` and per‑buffer filetype selection.
+
+### Architecture
+1. Core types (new):
+   - `enum class TokenKind { Default, Keyword, Type, String, Char, Comment, Number, Preproc, Constant, Function, Operator, Punctuation, Identifier, Whitespace, Error };`
+   - `struct HighlightSpan { int col_start; int col_end; TokenKind kind; };`  // 0‑based columns in buffer indices per rendered line
+   - `struct LineHighlight { std::vector<HighlightSpan> spans; uint64_t version; };`
+
+2. Interfaces (new):
+   - `class LanguageHighlighter { public: virtual ~LanguageHighlighter() = default; virtual void HighlightLine(const Buffer& buf, int row, std::vector<HighlightSpan>& out) const = 0; virtual bool Stateful() const { return false; } };`
+   - `class HighlighterEngine { public: void SetHighlighter(std::unique_ptr<LanguageHighlighter>); const LineHighlight& GetLine(const Buffer&, int row, uint64_t buf_version); void InvalidateFrom(int row); };`
+   - `class HighlighterRegistry { public: static const LanguageHighlighter& ForFiletype(std::string_view ft); static std::string DetectForPath(std::string_view path, std::string_view first_line); };`
+
+3. Editor/Buffer integration:
+   - Per‑Buffer settings: `bool syntax_enabled; std::string filetype; std::unique_ptr<HighlighterEngine> highlighter;`
+   - Buffer emits a monotonically increasing `version` on edit; renderers request line highlights by `(row, version)`. 
+   - Invalidate cache minimally on edits (v1: current line only; v2: from current line down when stateful constructs present).
+
+### Rendering integration
+- TerminalRenderer/GUIRenderer changes:
+  - During line rendering, query `Editor.CurrentBuffer()->highlighter->GetLine(buf, row, buf_version)` to obtain spans.
+  - Apply token styles while drawing glyph runs. 
+- Z‑order and blending:
+  1) Backgrounds (e.g., selection, search highlight rectangles) 
+  2) Text with syntax colors 
+  3) Cursor/IME decorations
+- Search highlights must remain visible over syntax colors:
+  - Terminal: combine color/attr with reverse/bold for search; if color conflicts, prefer search. 
+  - GUI: draw semi‑transparent rects behind text (already present); keep syntax color for text.
+
+### Theme and color mapping
+- Extend `GUITheme.h` with a `SyntaxPalette` mapping `TokenKind -> ImVec4 ink` (and optional background tint for comments/strings disabled by default). Provide default Light/Dark palettes. 
+- Terminal: map `TokenKind` to ncurses color pairs where available; degrade gracefully on 8/16‑color terminals (e.g., comments=dim, keywords=bold, strings=yellow/green if available). 
+
+### Language detection
+- v1: by file extension; allow manual `:set filetype=<lang>`. 
+- v2: add shebang detection for scripts, simple modelines (optional).
+
+### Commands/UX
+- `:syntax on|off` — global default; buffer inherits on open. 
+- `:set filetype=<lang>` — per‑buffer override. 
+- `:syntax reload` — rebuild patterns/themes. 
+- Status line shows filetype and syntax state when changed.
+
+### Implementation plan (phased)
+1. Phase 1 — Minimal regex highlighter for C/C++
+   - Implement `CppRegexHighlighter : LanguageHighlighter` with precompiled `std::regex` (or hand‑rolled simple scanners to avoid regex backtracking). Classes: line comment `//…`, block comment start `/*` (no state), string `"…"`, char `'…'` (no multiline), numbers, keywords/types, preprocessor `^\s*#\w+`. 
+   - Add `HighlighterEngine` with a simple per‑row cache keyed by `(row, buf_version)`; no background worker. 
+   - Integrate into both renderers; add palette to `GUITheme.h`; add terminal color selection. 
+   - Add commands. 
+
+2. Phase 2 — Stateful constructs and more languages
+   - Add state machine for multiline comments `/*…*/` and multiline strings (C++11 raw strings), with invalidation from edit line downward until state stabilizes. 
+   - Add simple highlighters: JSON (strings, numbers, booleans, null, punctuation), Markdown (headers/emphasis/code fences), Shell (comments, strings, keywords), Go (types, constants, keywords), Python (strings, comments, keywords), Rust (strings, comments, keywords), Lisp (comments, strings, keywords),. 
+   - Filetype detection by extension + shebang. 
+
+3. Phase 3 — Performance and caching
+   - Viewport‑first highlighting: compute only visible rows each frame; background task warms cache around viewport. 
+   - Reuse span buffers, avoid allocations; small‑vector optimization if needed. 
+   - Bench with large files; ensure O(n_visible) cost per frame.
+
+4. Phase 4 — Extensibility
+   - Public registration API for external highlighters. 
+   - Optional Tree‑sitter adapter behind a compile flag (off by default) to keep dependencies minimal. 
+
+### Data flow (per frame)
+- Renderer asks Editor for Buffer and viewport rows. 
+- For each row: `engine.GetLine(buf, row, buf.version)` → spans. 
+- Renderer emits runs with style from `SyntaxPalette[kind]`. 
+- Search highlights are applied as separate background rectangles (GUI) or attribute toggles (Terminal), not overriding text color.
+
+### Testing
+- Unit tests for tokenization per language: golden inputs → spans. 
+- Fuzz/edge cases: escaped quotes, numeric literals, preprocessor lines. 
+- Renderer tests with `TestRenderer` asserting the sequence of style changes for a line. 
+- Performance tests: highlight 1k visible lines repeatedly; assert time under threshold.
+
+### Risks and mitigations
+- Regex backtracking/perf: prefer linear scans; precompute keyword tables; avoid nested regex. 
+- Terminal color limitations: feature‑detect colors; provide bold/dim fallbacks. 
+- Stateful correctness: invalidate conservatively (from edit line downward) and cap work per frame.
+
+### Deliverables
+- New files: `Highlight.h/.cc`, `HighlighterEngine.h/.cc`, `LanguageHighlighter.h`, `CppHighlighter.h/.cc`, optional `HighlighterRegistry.h/.cc`. 
+- Renderer updates: `GUIRenderer.cc`, `TerminalRenderer.cc` to consume spans. 
+- Theming: `GUITheme.h` additions for syntax colors. 
+- Editor/Buffer: per‑buffer syntax settings and highlighter handle. 
+- Commands in `Command.cc` and help text updates. 
+- Docs: README/ROADMAP update and a brief `docs/syntax.md`. 
+- Tests: unit and renderer golden tests.
--- a/docs/undo-roadmap.md
+++ b/docs/undo-roadmap.md
@@ -0,0 +1,279 @@
+Undo System Overhaul Roadmap (emacs-style undo-tree)
+
+Context: macOS, C++17 project, ncurses terminal and SDL2/ImGui GUI frontends. Date: 2025-12-01.
+
+Purpose
+
+- Define a clear, incremental plan to implement a robust, non-linear undo system inspired by emacs' undo-tree.
+- Align implementation with docs/undo.md and fix gaps observed in docs/undo-state.md.
+- Provide test cases and acceptance criteria so a junior engineer or agentic coding system can execute the plan safely.
+
+References
+
+- Specification: docs/undo.md (API, invariants, batching rules, raw buffer ops)
+- Current snapshot and recent fix: docs/undo-state.md (GUI mapping notes; Begin/Append ordering fix)
+- Code: UndoSystem.{h,cc}, UndoTree.{h,cc}, UndoNode.{h,cc}, Buffer.{h,cc}, Command.{h,cc}, GUI/Terminal InputHandlers,
+  KKeymap.
+
+Instrumentation (KTE_UNDO_DEBUG)
+
+- How to enable
+  - Build with the CMake option `-DKTE_UNDO_DEBUG=ON` to enable concise instrumentation logs from `UndoSystem`.
+  - The following targets receive the `KTE_UNDO_DEBUG` compile definition when ON:
+    - `kte` (terminal), `kge` (GUI), and `test_undo` (tests).
+  - Examples:
+    ```sh
+    # Terminal build with tests and instrumentation ON
+    cmake -S . -B cmake-build-term -DBUILD_TESTS=ON -DBUILD_GUI=OFF -DKTE_UNDO_DEBUG=ON
+    cmake --build cmake-build-term --target test_undo -j
+    ./cmake-build-term/test_undo 2> undo.log
+
+    # GUI build (requires SDL2/OpenGL/Freetype toolchain) with instrumentation ON
+    cmake -S . -B cmake-build-gui -DBUILD_GUI=ON -DKTE_UNDO_DEBUG=ON
+    cmake --build cmake-build-gui --target kge -j
+    # Run kge and perform actions; logs go to stderr
+    ```
+
+- What it logs
+  - Each Begin/Append/commit/undo/redo operation prints a single `[UNDO]` line with:
+    - current cursor `(row,col)`, pointer to `pending`, its type/row/col/text-size, and pointers to `current`/`saved`.
+  - Example fields: `[UNDO] Begin cur=(0,0) pending=0x... t=Insert r=0 c=0 nlen=2 current=0x... saved=0x...`
+
+- Example trace snippets
+  - Typing a contiguous word ("Hello") batches into a single Insert node; one commit occurs before the subsequent undo:
+    ```text
+    [UNDO] Begin cur=(0,0) pending=0x0 t=- r=-1 c=-1 nlen=0 current=0x0 saved=0x0
+    [UNDO] commit:enter cur=(0,0) pending=0x0 t=- r=-1 c=-1 nlen=0 current=0x0 saved=0x0
+    [UNDO] Begin:new cur=(0,0) pending=0x... t=Insert r=0 c=0 nlen=0 current=0x0 saved=0x0
+    [UNDO] Append:sv cur=(0,0) pending=0x... t=Insert r=0 c=0 nlen=1 current=0x0 saved=0x0
+    ... (more Append as characters are typed) ...
+    [UNDO] commit:enter cur=(0,5) pending=0x... t=Insert r=0 c=0 nlen=5 current=0x0 saved=0x0
+    [UNDO] commit:done cur=(0,5) pending=0x0 t=- r=-1 c=-1 nlen=0 current=0x... saved=0x0
+    ```
+
+  - Undo then Redo across that batch:
+    ```text
+    [UNDO] commit:enter cur=(0,5) pending=0x0 t=- r=-1 c=-1 nlen=0 current=0x... saved=0x0
+    [UNDO] undo cur=(0,5) pending=0x0 t=- r=-1 c=-1 nlen=0 current=0x0 saved=0x0
+    [UNDO] commit:enter cur=(0,5) pending=0x0 t=- r=-1 c=-1 nlen=0 current=0x0 saved=0x0
+    [UNDO] redo cur=(0,5) pending=0x0 t=- r=-1 c=-1 nlen=0 current=0x... saved=0x0
+    ```
+
+  - Newline and backspace/delete traces follow the same pattern with `t=Newline` or `t=Delete` and immediate commit for newline.
+    Capture by running `kge`/`kte` with `KTE_UNDO_DEBUG=ON` and performing the actions; append representative 3–6 line snippets to docs.
+
+Notes
+
+- Pointer values and exact cursor positions in the logs depend on the runtime and actions; this is expected.
+- Keep `KTE_UNDO_DEBUG` OFF by default in CI/release to avoid noisy logs and any performance impact.
+
+̄1) Current State Summary (from docs/undo-state.md)
+
+- Terminal (kte): Keybindings and UndoSystem integration have been stable.
+- GUI (kge): Previously, C-k u/U mapping and SDL TEXTINPUT suppression had issues on macOS; these were debugged. The
+  core root cause of “status shows Undone but no change” was fixed by moving UndoSystem::Begin/Append/commit to occur
+  after buffer modifications/cursor updates so batching conditions see the correct cursor.
+- Undo core exists with tree invariants, saved marker/dirty flag mirroring, batching for Insert/Delete, and Newline as a
+  single-step undo.
+
+Gaps/Risks
+
+- Event-path unification between KEYDOWN and TEXTINPUT across platforms (macOS specifics).
+- Comprehensive tests for branching, GC/limits, multi-line operations, and UTF-8 text input.
+- Advanced/compound command grouping and future region operations.
+
+
+2) Design Goals (emacs-like undo-tree)
+
+- Per-buffer, non-linear undo tree: new edits after undo create a branch; existing redo branches are discarded.
+- Batching: insert/backspace/paste/newline grouped into sensible units to match user expectations.
+- Silent apply during undo/redo (no re-recording), using raw Buffer methods only.
+- Correct saved/dirty tracking and robust pending node lifecycle (detached until commit).
+- Efficient memory behavior; optional pruning limits similar to emacs (undo-limit, undo-strong-limit).
+- Deterministic behavior across terminal and GUI frontends.
+
+
+3) Invariants and API (must align with docs/undo.md)
+
+- UndoTree holds root/current/saved/pending; pending is detached and only linked on commit.
+- Begin(type) reuses pending only if: same type, same row, and pending->col + pending->text.size() == current cursor
+  col (or prepend rules for backspace sequences); otherwise it commits and starts a new node.
+- commit(): frees redo siblings from current, attaches pending as current->child, advances current, clears pending;
+  nullifies saved marker if diverged.
+- undo()/redo(): move current and apply the node using low-level Buffer APIs that do not trigger undo recording.
+- mark_saved(): updates saved pointer and dirty flag (dirty ⇔ current != saved).
+- discard_pending()/clear(): lifecycle for buffer close/reset/new file.
+
+
+4) Phased Roadmap
+
+Phase 0 — Baseline & Instrumentation (1 day)
+
+- Audit UndoSystem against docs/undo.md invariants; ensure apply() uses only raw Buffer ops.
+- Verify Begin/Append ordering across all edit commands: insert, backspace, delete, newline, paste.
+- Add a temporary debug toggle (compile-time or editor flag) to log Begin/Append/commit/undo/redo, cursor(row,col), node
+  sizes, and pending state. Include assertions for: pending detached, commit clears pending, redo branch freed on new
+  commit, and correct batching preconditions.
+- Deliverables: Short log from typing/undo/redo scenarios; instrumentation behind a macro so it can be removed.
+
+Phase 1 — Input Path Unification & Batching Rules (1–2 days)
+
+- Ensure all printable text insertion (terminal and GUI) flows through CommandId::InsertText and reaches UndoSystem
+  Begin/Append. On SDL, handle KEYDOWN vs TEXTINPUT consistently; always suppress trailing TEXTINPUT after k-prefix
+  suffix commands.
+- Commit boundaries: at k-prefix entry, before Undo/Redo, on cursor movement, on focus/file ops, and before any
+  non-editing command that should separate undo units.
+- Batching heuristics:
+    - Insert: same row, contiguous columns; Append(std::string_view) handles multi-character text (pastes, IME).
+    - Backspace: prepend batching in increasing column order (store deleted text in forward order).
+    - Delete (forward): contiguous at same row/col.
+    - Newline: record as UndoType::Newline and immediately commit (single-step undo for line splits/joins).
+- Deliverables: Manual tests pass for typing/backspace/delete/newline/paste; GUI C-k u/U work as expected on macOS.
+
+Phase 2 — Tree Limits & GC (1 day)
+
+- Add configurable memory/size limits for undo data (soft and strong limits like emacs). Implement pruning of oldest
+  ancestors or deep redo branches while preserving recent edits. Provide stats (node count, bytes in text storage).
+- Deliverables: Config hooks, tests demonstrating pruning without violating apply/undo invariants.
+
+Phase 3 — Compound Commands & Region Ops (2–3 days)
+
+- Introduce an optional RAII-style UndoTransaction to group multi-step commands (indent region, kill region, rectangle
+  ops) into a single undo step. Internally this just sequences Begin/Append and ensures commit even on early returns.
+- Support row operations (InsertRow/DeleteRow) with proper raw Buffer calls. Ensure join_lines/split_line are handled by
+  Newline nodes or dedicated types if necessary.
+- Deliverables: Commands updated to use transactions when appropriate; tests for region delete/indent and multi-line
+  paste.
+
+Phase 4 — Developer UX & Diagnostics (1 day)
+
+- Add a dev command to dump the undo tree (preorder) with markers for current/saved and pending (detached). For GUI,
+  optionally expose a simple ImGui debug window (behind a compile flag) that visualizes the current branch.
+- Editor status improvements: show short status codes for undo/redo and when a new branch was created or redo discarded.
+- Deliverables: Tree dump command; example output in docs.
+
+Phase 5 — Comprehensive Tests & Property Checks (2–3 days)
+
+- Unit tests (extend test_undo.cc):
+    - Insert batching: type "Hello" then one undo removes all; redo restores.
+    - Backspace batching: type "Hello", backspace 3×, undo → restores the 3; redo → re-applies deletion.
+    - Delete batching (forward delete) with cursor not moving.
+    - Newline: split a line and undo to join; join a line (via backspace at col 0) and undo to split.
+    - Branching: type "abc", undo twice, type "X" → redo history discarded; ensure redo no longer restores 'b'/'c'.
+    - Saved/dirty: mark_saved after typing; ensure dirty flag toggles correctly after undo/redo; saved marker tracks the
+      node.
+    - discard_pending: create pending by typing, then move cursor or invoke commit boundary; ensure pending is attached;
+      also ensure discard on buffer close clears pending.
+    - clear(): resets state with no leaks; tree pointers null.
+    - UTF-8 input: insert multi-byte characters via InsertText with multi-char std::string; ensure counts/col tracking
+      behave (text stored as bytes; editor col policy consistent within kte).
+- Integration tests (TestFrontend):
+    - Both TerminalFrontend and GUIFrontend: simulate text input and commands, including k-prefix C-k u/U.
+    - Paste scenarios: multi-character insertions batched as one.
+- Property tests (optional but recommended):
+    - Generate random sequences of edits; record them; then apply undo until root and redo back to the end → buffer
+      contents match at each step; no crashes; dirty flag transitions consistent. Seed-based to reproduce failures.
+    - Redo-branch discard property: any new edit after undo must eliminate redo path; redoing should be impossible
+      afterward.
+- Deliverables: Tests merged and passing on CI for both frontends; failures block changes to undo core.
+
+Phase 6 — Performance & Stress (0.5–1 day)
+
+- Stress test with large files and long edit sequences. Target: smooth typing at 10k+ ops/minute on commodity hardware;
+  memory growth bounded when GC limits enabled.
+- Deliverables: Basic perf notes; optional lightweight benchmarks.
+
+
+5) Acceptance Criteria
+
+- Conformance to docs/undo.md invariants and API surface (including raw Buffer operations for apply()).
+- Repro checklist passes:
+    - Type text; single-step undo/redo works and respects batching.
+    - Backspace/delete batching works.
+    - Newline split/join are single-step undo/redo.
+    - Branching works: undo, then type → redo path is discarded; no ghost redo.
+    - Saved/dirty flags accurate across undo/redo and diverge/rejoin paths.
+    - No pending nodes leaked on buffer close/reload; no re-recording during undo/redo.
+    - Behavior identical across terminal and GUI input paths.
+- Tests added for all above; CI green.
+
+
+6) Concrete Work Items by File
+
+- UndoSystem.h/cc:
+    - Re-verify Begin/Append ordering; enforce batching invariants; prepend logic for backspace; immediate commit for
+      newline.
+    - Implement/verify apply() uses only Buffer raw methods: insert_text/delete_text/split_line/join_lines/row ops.
+    - Add limits (configurable) and stats; add discard_pending safety paths.
+- Buffer.h/cc:
+    - Ensure raw methods exist and do not trigger undo; ensure UpdateBufferReference is correctly used when
+      replacing/renaming the underlying buffer.
+    - Call undo.commit() on cursor movement and non-editing commands (via Command layer integration).
+- Command.cc:
+    - Ensure all edit commands drive UndoSystem correctly; commit at k-prefix entry and before Undo/Redo.
+    - Introduce UndoTransaction for compound commands when needed.
+- GUIInputHandler.cc / TerminalInputHandler.cc / KKeymap.cc:
+    - Ensure unified InsertText path; suppress SDL_TEXTINPUT when a k-prefix suffix produced a command; preserve case
+      mapping.
+- Tests: test_undo.cc (extend) + new tests (e.g., test_undo_branching.cc, test_undo_multiline.cc).
+
+
+7) Example Test Cases (sketches)
+
+- Branch discard after undo:
+    1) InsertText("abc"); Undo(); Undo(); InsertText("X"); Redo();
+       Expected: Redo is a no-op (or status indicates no redo), buffer is "aX".
+
+- Newline split/join:
+    1) InsertText("ab"); Newline(); InsertText("c"); Undo();
+       Expected: single undo joins lines → buffer "abc" on one line at original join point; Redo() splits again.
+
+- Backspace batching:
+    1) InsertText("hello"); Backspace×3; Undo();
+       Expected: restores "hello".
+
+- UTF-8 insertion:
+    1) InsertText("😀汉"); Undo(); Redo();
+       Expected: content unchanged across cycles; no crashes.
+
+- Saved/dirty transitions:
+    1) InsertText("hi"); mark_saved(); InsertText("!"); Undo(); Redo();
+       Expected: dirty false after mark_saved; dirty true after InsertText("!"); dirty returns to false after Undo();
+       true again after Redo().
+
+
+8) Risks & Mitigations
+
+- SDL/macOS event ordering (KEYDOWN vs TEXTINPUT, IME): Mitigate by suppressing TEXTINPUT on mapped k-prefix suffixes;
+  optionally temporarily disable SDL text input during k-prefix suffix mapping; add targeted diagnostics.
+- UTF-8 width vs byte-length: Store bytes in UndoNode::text; keep column logic consistent with existing Buffer
+  semantics.
+- Memory growth: Add GC/limits and provide a way to clear/reduce history for huge sessions.
+- Re-entrancy during apply(): Prevent public edit paths from being called; use only raw operations.
+
+
+9) Nice-to-Have (post-MVP)
+
+- Visual undo-tree navigation (emacs-like time travel and branch selection), at least as a debug tool initially.
+- Persistent undo across saves (opt-in; likely out-of-scope initially).
+- Time-based batching threshold (e.g., break batches after >500ms pause in typing).
+
+
+10) Execution Notes for a Junior Engineer/Agentic System
+
+- Start from Phase 0; do not skip instrumentation—assertions will catch subtle batching bugs early.
+- Change one surface at a time; when adjusting Begin/Append/commit positions, re-run unit tests immediately.
+- Always ensure commit boundaries before invoking commands that move the cursor/state.
+- When unsure about apply(), read docs/undo.md and mirror exactly: only raw Buffer methods, never the public editing
+  APIs.
+- Keep diffs small and localized; add tests alongside behavior changes.
+
+Appendix A — Minimal Developer Checklist
+
+- [ ] Begin/Append occur after buffer mutation and cursor updates for all edit commands.
+- [ ] Pending detached until commit; freed/cleared on commit/discard/clear.
+- [ ] Redo branches freed on new commit after undo.
+- [ ] mark_saved updates both saved pointer and dirty flag; dirty mirrors current != saved.
+- [ ] apply() uses only raw Buffer methods; no recording during apply.
+- [ ] Terminal and GUI both route printable input to InsertText; k-prefix mapping suppresses trailing TEXTINPUT.
+- [ ] Unit and integration tests cover batching, branching, newline, saved/dirty, and UTF-8 cases.
--- a/docs/undo-state.md
+++ b/docs/undo-state.md
@@ -1,128 +1,139 @@
-Undo/Redo + C-k GUI status (macOS) — current state snapshot
+### Context recap

-Context
- - Platform: macOS (Darwin)
- - Target: GUI build (kge) using SDL2/ImGui path
- - Date: 2025-11-30 00:30 local (from user)
+- The undo system is now tree‑based with batching rules and `KTE_UNDO_DEBUG` instrumentation hooks already present in
+  `UndoSystem.{h,cc}`.
+- GUI path uses SDL; printable input now flows exclusively via `SDL_TEXTINPUT` to `CommandId::InsertText`, while
+  control/meta/movement (incl. Backspace/Delete/Newline and k‑prefix) come from `SDL_KEYDOWN`.
+- Commit boundaries must be enforced at well‑defined points (movement, non‑editing commands, newline, undo/redo, etc.).

-What works right now
- - Terminal (kte): C-k keymap and UndoSystem integration have been stable in recent builds.
- - GUI: Most C-k mappings work: C-k d (KillToEOL), C-k x (Save+Quit), C-k q (Quit) — confirmed by user.
- - UndoSystem core is implemented and integrated for InsertText/Newline/Delete/Backspace. Buffer owns an UndoSystem and raw edit APIs are used by apply().
+### Status summary (2025‑12‑01)

-What is broken (GUI, macOS)
- - C-k u: Status shows "Undone" but buffer content does not change (no visible undo).
- - C-k U: Inserts a literal 'U' into the buffer; does not execute Redo.
- - C-k C-u / C-k C-U: No effect (expected unmapped), but the k-prefix prompt can remain in some paths.
+- Input‑path unification: Completed. `GUIInputHandler.cc` routes all printable characters through `SDL_TEXTINPUT → InsertText`.
+  Newlines originate only from `SDL_KEYDOWN → Newline`. CR/LF are filtered out of `SDL_TEXTINPUT` payloads. Suppression
+  rules prevent stray `TEXTINPUT` after meta/prefix/universal‑argument flows. Terminal input path remains consistent.
+- Tests: `test_undo.cc` expanded to cover branching behavior, UTF‑8 insertion, multi‑line newline/join, and typing batching.
+  All scenarios pass.
+- Instrumentation: `KTE_UNDO_DEBUG` hooks exist in `UndoSystem.{h,cc}`; a CMake toggle has not yet been added.
+- Commit boundaries: Undo/Redo commit boundaries are in place; newline path commits immediately by design. A final audit
+  pass across movement/non‑editing commands is still pending.
+- Docs: This status document updated. Further docs (instrumentation how‑to and example traces) remain pending in
+  `docs/undo.md` / `docs/undo-roadmap.md`.

-Repro steps (GUI)
- 1) Type "Hello".
- 2) Press C-k then press u → status becomes "Undone", but text remains "Hello".
- 3) Press C-k then press Shift+U → a literal 'U' is inserted (becomes "HelloU").
- 4) Press C-k then hold Ctrl on the suffix and press u → status "Undone", still no change.
- 5) Press C-k then hold Ctrl on the suffix and press Shift+U → status shows the k-prefix prompt again ("C-k _").
+### Objectives

-Keymap and input-layer changes we attempted (and kept)
- - KKeymap.cc: Case-sensitive 'U' mapping prioritized before the lowercase table. Added ctrl→non-ctrl fall-through so C-k u/U still map even if SDL reports Ctrl held on the suffix.
- - TerminalInputHandler: already preserved case and mapped correctly.
- - GUIInputHandler:
-   - Preserve case for k-prefix suffix letters (Shift → uppercase). Clear esc_meta before k-suffix mapping.
-   - Strengthened SDL_TEXTINPUT suppression after a k-prefix printable suffix to avoid inserting literal characters.
-   - Added fallback to map the k-prefix suffix in the SDL_TEXTINPUT path (to catch macOS cases where uppercase arrives in TEXTINPUT rather than KEYDOWN).
-   - Fixed malformed switch block introduced during iteration.
- - Command layer: commit pending undo batch at k-prefix entry and just before Undo/Redo so prior typing can actually be undone/redone.
+- Use the existing instrumentation to capture short traces of typing/backspacing/deleting and undo/redo.
+- Unify input paths (SDL `KEYDOWN` vs `TEXTINPUT`) and lock down commit boundaries across commands.
+- Extend tests to cover branching behavior, UTF‑8, and multi‑line operations.

-Diagnostics added
- - GUIInputHandler logs k-prefix u/U suffix attempts to stderr and (previously) /tmp/kge.log. The user’s macOS session showed only KEYDOWN logs for 'u':
-   - "[kge] k-prefix suffix: sym=117 mods=0x0 ascii=117 'u' ctrl2=0 pass_ctrl=0 mapped=1 id=38"
-   - "[kge] k-prefix suffix: sym=117 mods=0x80 ascii=117 'u' ctrl2=1 pass_ctrl=0 mapped=1 id=38"
- - No logs were produced for 'U' (neither KEYDOWN nor TEXTINPUT). The /tmp log file was not created on the user’s host in the last run (stderr logs were visible earlier from KEYDOWN).
+### Plan of action

-Hypotheses for current failures
- 1) Undo appears to be invoked (status "Undone"), but no state change:
-    - The most likely cause is that no committed node exists at the time of undo (i.e., typing "Hello" is not being recorded as an undo node), because our current typing path in Command.cc directly edits buffer rows without always driving UndoSystem Begin/Append/commit at the right times for every printable char on GUI.
-    - Although we call u->Begin(Insert) and u->Append(text) in cmd_insert_text for CommandId::InsertText, the GUI printable input might be arriving through a different path or being short-circuited (e.g., via a prompt or suppression), resulting in actual text insertion but no corresponding UndoSystem pending node content, or pending but never committed.
-    - We now commit at k-prefix entry and before undo; if there is still "nothing to undo", it implies the batch never had text appended (Append not called) or is detached from the real buffer edits.
+1. Enable instrumentation and make it easy to toggle
+    - Add a CMake option in `CMakeLists.txt` (root project):
+      `option(KTE_UNDO_DEBUG "Enable undo instrumentation logs" OFF)`.
+    - When ON, add a compile definition `-DKTE_UNDO_DEBUG` to all targets that include the editor core (e.g., `kte`,
+      `kge`, and test binaries).
+    - Keep the default OFF so normal builds are quiet; ensure both modes compile in CI.

- 2) Redo via C-k U inserts a literal 'U':
-    - On macOS, uppercase letters often arrive as SDL_TEXTINPUT events. We added TEXTINPUT-based k-prefix mapping, but the user's run still showed a literal insertion and no diagnostic lines for TEXTINPUT, which suggests:
-      a) The TEXTINPUT suppression didn’t trigger for that platform/sequence, or
-      b) The k-prefix flag was already cleared by the time TEXTINPUT arrived, so the TEXTINPUT path defaulted to InsertText, or
-      c) The GUI window’s input focus or SDL event ordering differs from expectations (e.g., IME/text input settings), so our suppression/mapping didn’t see the event.
+2. Capture short traces to validate current behavior
+    - Build with `-DKTE_UNDO_DEBUG=ON` and run the GUI frontend:
+        - Scenario A: type a contiguous word, then move cursor (should show `Begin(Insert)` + multiple `Append`, single
+          `commit` at a movement boundary).
+        - Scenario B: hold backspace to delete a run, including backspace batching (prepend rule); verify
+          `Begin(Delete)` with prepended `Append` behavior, single `commit`.
+        - Scenario C: forward deletes at a fixed column (anchor batching); expected single `Begin(Delete)` with same
+          column.
+        - Scenario D: insert newline (`Newline` node) and immediately commit; type text on the next line; undo/redo
+          across the boundary.
+        - Scenario E: undo chain and redo chain; then type new text and confirm redo branch gets discarded in logs.
+    - Save representative trace snippets and add to `docs/undo.md` or `docs/undo-roadmap.md` for reference.

-Relevant code pointers
- - Key mapping tables: KKeymap.cc → KLookupKCommand() (C-k suffix), KLookupCtrlCommand(), KLookupEscCommand().
- - Terminal input: TerminalInputHandler.cc → map_key_to_command().
- - GUI input: GUIInputHandler.cc → map_key() and GUIInputHandler::ProcessSDLEvent() (KEYDOWN + TEXTINPUT handling, suppression, k_prefix_/esc_meta_ flags).
- - Command dispatch: Command.cc → cmd_insert_text(), cmd_newline(), cmd_backspace(), cmd_delete_char(), cmd_undo(), cmd_redo(), cmd_kprefix().
- - Undo core: UndoSystem.{h,cc}, UndoNode.{h,cc}, UndoTree.{h,cc}. Buffer raw methods used by apply().
+3. Input‑path unification (SDL `KEYDOWN` vs `TEXTINPUT`) — Completed 2025‑12‑01
+    - In `GUIInputHandler.cc`:
+        - Ensure printable characters are generated exclusively from `SDL_TEXTINPUT` and mapped to
+          `CommandId::InsertText`.
+        - Keep `SDL_KEYDOWN` for control/meta/movement, backspace/delete, newline, and k‑prefix handling.
+        - Maintain suppression of stray `SDL_TEXTINPUT` immediately following meta/prefix or universal‑argument
+          collection so no accidental text is inserted.
+        - Confirm that `InsertText` path never carries `"\n"`; newline must only originate from `KEYDOWN` →
+          `CommandId::Newline`.
+    - If the terminal input path exists, ensure parity: printable insertions go through `InsertText`, control via key
+      events, and the same commit boundaries apply.
+    - Status: Implemented. See `GUIInputHandler.cc` changes; tests confirm parity with terminal path.

-Immediate next steps (when we return to this)
- 1) Verify that GUI printable insertion always flows through CommandId::InsertText so UndoSystem::Begin/Append gets called. If SDL_TEXTINPUT delivers multi-byte strings, ensure Append() is given the same text inserted into buffer.
-    - Add a one-session debug hook in cmd_insert_text to assert/trace: pending node type/text length and current cursor col before/after.
-    - If GUI sometimes sends CommandId::InsertTextEmpty or another path, unify.
+4. Enforce and verify commit boundaries in command execution — In progress
+    - Audit `Command.cc` and ensure `u->commit()` is called before executing any non‑editing command that should end a
+      batch:
+        - Movement commands (left/right/up/down/home/end/page).
+        - Prompt accept/cancel transitions and mode switches (search prompts, replace prompts).
+        - Buffer/file operations (open/switch/save/close), and focus changes.
+        - Before running `Undo` or `Redo` (already present).
+    - Ensure immediate commit at the end of atomic edit operations:
+        - `Newline` insertion and line joins (`Delete` of newline when backspacing at column 0) should create
+          `UndoType::Newline` and commit immediately (parts are already implemented; verify all call sites).
+        - Pastes should be a single `Paste`/`Insert` batch per operation (depending on current design).

- 2) Ensure batching rules are satisfied so Begin() reuses pending correctly:
-    - Begin(Insert) must see same row and col == pending->col + pending->text.size() for typing sequences.
-    - If GUI accumulates multiple characters per TEXTINPUT (e.g., pasted text), Append(std::string_view) is fine, but row/col expectations remain.
+5. Extend automated tests (or add them if absent) — Phase 1 completed
+    - Branching behavior ✓
+        - Insert `"abc"`, undo twice (back to `"a"`), insert `"X"`, assert redo list is discarded, and new timeline
+          continues with `aX`.
+        - Navigate undo/redo along the new branch to ensure correctness.
+    - UTF‑8 insertion and deletion ✓
+        - Insert `"é漢"` (multi‑byte characters) via `InsertText`; verify buffer content and that a single Insert batch
+          is created.
+        - Undo/redo restores/removes the full insertion batch.
+        - Backspace after typed UTF‑8 should remove the last inserted codepoint from the batch in a single undo step (
+          current semantics are byte‑oriented in buffer ops; test to current behavior and document).
+    - Multi‑line operations ✓
+        - Newline splits a line: verify an `UndoType::Newline` node is created and committed immediately; undo/redo
+          round‑trip.
+        - Backspace at column 0 joins with previous line: record as `Newline` deletion (via `UndoType::Newline`
+          inverse); undo/redo round‑trip.
+    - Typing and deletion batching ✓ (typing) / Pending (delete batching)
+        - Typing a contiguous word (no cursor moves) yields one `Insert` node with accumulated text.
+        - Forward delete at a fixed anchor column yields one `Delete` batch. (Pending test)
+        - Backspace batching uses the prepend rule when the cursor moves left. (Pending test)
+    - Place tests near existing test suite files (e.g., `tests/test_undo.cc`) or create them if not present. Prefer
+      using `Buffer` + `UndoSystem` directly for tight unit tests; add higher‑level integration tests as needed.

- 3) For C-k U uppercase mapping on macOS:
-    - Add a temporary status dump when k-prefix suffix mapping falls back to TEXTINPUT path (we added stderr prints; also set Editor status with a short code like "K-TI U" during one session) to confirm path is used and suppression is working.
-    - If TEXTINPUT never arrives, force suppression: when we detect k-prefix and KEYDOWN of a letter with Shift, preemptively handle via KEYDOWN-derived uppercase ASCII rather than deferring.
+6. Documentation updates — In progress
+    - In `docs/undo.md` and `docs/undo-roadmap.md`:
+        - Describe how to enable instrumentation (`KTE_UNDO_DEBUG`) and an example of trace logs.
+        - List batching rules and commit boundaries clearly with examples.
+        - Document current UTF‑8 semantics (byte‑wise vs codepoint‑wise) and any known limitations.
+    - Current status: this `undo-state.md` updated; instrumentation how‑to and example traces pending.

- 4) Consolidate k-prefix handling:
-    - After mapping a k-prefix suffix to a command (Undo/Redo/etc.), always set suppress_text_input_once_ = true to avoid any trailing TEXTINPUT.
-    - Clear k_prefix_ reliably on both KEYDOWN and TEXTINPUT paths.
+7. CI and build hygiene — Pending
+    - Default builds: `KTE_UNDO_DEBUG` OFF.
+    - Add a CI job that builds and runs tests with `KTE_UNDO_DEBUG=ON` to ensure the instrumentation path remains
+      healthy.
+    - Ensure no performance regressions or excessive logging in release builds.

- 5) Once mapping is solid, remove all diagnostics and keep the minimal, deterministic logic.
+8. Stretch goals (optional, time‑boxed) — Pending
+    - IME composition: confirm that `SDL_TEXTINPUT` behavior during IME composition does not produce partial/broken
+      insertions; if needed, buffer composition updates into a single commit.
+    - Ensure paste operations (multi‑line/UTF‑8) remain atomic in undo history.

-Open questions for future debugging
- - Does SDL on this macOS setup deliver Shift+U as KEYDOWN+TEXTINPUT consistently, or only TEXTINPUT? We need a small on-screen debug to avoid relying on stderr.
- - Are there any IME/TextInput SDL hints on macOS we should set for raw key handling during k-prefix?
- - Should we temporarily disable SDL text input (SDL_StopTextInput) during k-prefix suffix processing to eliminate TEXTINPUT races on macOS?
+### How to run the tests

-Notes on UndoSystem correctness (unrelated to the GUI mapping bug)
- - Undo tree invariants are implemented: pending is detached; commit attaches and clears redo branches; undo/redo apply low-level Buffer edits with no public editor paths; saved marker updated via mark_saved().
- - Dirty flag mirrors (current != saved).
- - Delete batching supports prepend for backspace sequences (stored text is in increasing column order from anchor).
- - Newline joins/splits are recorded as UndoType::Newline and committed immediately for single-step undo of line joins.
+- Configure with `-DBUILD_TESTS=ON` and build the `test_undo` target. Run the produced binary (e.g., `./test_undo`).
+  The test prints progress and uses assertions to validate behavior.

-Owner pointers & file locations
- - GUI mapping and suppression: GUIInputHandler.cc
- - Command layer commit boundaries: Command.cc (cmd_kprefix, cmd_undo, cmd_redo)
- - Undo batching entry points: Command.cc (cmd_insert_text, cmd_backspace, cmd_delete_char, cmd_newline)
+### Deliverables

-End of snapshot — safe to resume from here.
+- CMake toggle for instrumentation and verified logs for core scenarios. (Pending)
+- Updated `GUIInputHandler.cc` solidifying `KEYDOWN` vs `TEXTINPUT` separation and suppression rules. (Completed)
+- Verified commit boundaries in `Command.cc` with comments where appropriate. (In progress)
+- New tests for branching, UTF‑8, and multi‑line operations; all passing. (Completed for listed scenarios)
+- Docs updated with how‑to and example traces. (Pending)

---
+### Acceptance criteria

-RESOLUTION (2025-11-30)
+### Current status (2025‑12‑01) vs acceptance criteria

-Root Cause Identified and Fixed
-The undo system failure was caused by incorrect timing of UndoSystem::Begin() and Append() calls relative to buffer modifications in Command.cc.
-
-Problem:
- In cmd_insert_text, cmd_backspace, cmd_delete_char, and cmd_newline, the undo recording (Begin/Append) was called BEFORE the actual buffer modification and cursor update.
- UndoSystem::Begin() checks the current cursor position to determine if it can batch with the pending node.
- For Insert type: Begin() checks if col == pending->col + pending->text.size()
- For Delete type: Begin() checks if the cursor is at the expected position based on whether it's forward delete or backspace
- When Begin/Append were called before cursor updates, the batching condition would fail on the second character because the cursor hadn't moved yet from the first insertion.
- This caused each character to create a separate batch, but since commit() was never called between characters (only at k-prefix or undo), the pending node would be overwritten rather than committed, resulting in no undo history.
-
-Fix Applied:
- cmd_insert_text: Moved Begin/Append to AFTER buffer insertion (lines 854-856) and cursor update (line 857).
- cmd_backspace: Moved Begin/Append to AFTER character deletion (lines 1024-1025) and cursor decrement (line 1026).
- cmd_delete_char: Moved Begin/Append to AFTER character deletion (lines 1074-1076).
- cmd_newline: Moved Begin/commit to AFTER line split (lines 956-966) and cursor update (lines 963-967).
-
-Result:
- Begin() now sees the correct cursor position after each edit, allowing proper batching of consecutive characters.
- Typing "Hello" will now create a single pending batch with all 5 characters that can be undone as one unit.
- The fix applies to both terminal (kte) and GUI (kge) builds.
-
-Testing Recommendation:
- Type several characters (e.g., "Hello")
- Press C-k u to undo - the entire word should disappear
- Press C-k U to redo - the word should reappear
- Test backspace batching: type several characters, then backspace multiple times, then undo - should undo the backspace batch
- Test delete batching similarly
+- Short instrumentation traces match expected batching and commit behavior for typing, backspace/delete, newline, and
+  undo/redo. — Pending (instrumentation toggle + capture not done)
+- Printable input comes exclusively from `SDL_TEXTINPUT`; no stray inserts after meta/prefix/universal‑argument flows.
+  — Satisfied (GUI path updated; terminal path consistent)
+- Undo branching behaves correctly; redo is discarded upon new commits after undo. — Satisfied (tested)
+- UTF‑8 and multi‑line scenarios round‑trip via undo/redo according to the documented semantics. — Satisfied (tested)
+- Tests pass with `KTE_UNDO_DEBUG` both OFF and ON. — Pending (no CMake toggle yet; default OFF passes)
--- a/flake-gui.nix
+++ b/flake-gui.nix
@@ -1,55 +0,0 @@
-# flake.nix
-{
-  description = "kte  ImGui/SDL2 text editor";
-
-  inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
-    flake-utils.url = "github:numtide/flake-utils";
-  };
-
-  outputs = { self, nixpkgs, flake-utils }:
-    flake-utils.lib.eachDefaultSystem (system:
-      let
-        pkgs = nixpkgs.legacyPackages.${system};
-      in {
-        packages.default = pkgs.stdenv.mkDerivation {
-          pname = "kte";
-          version = "0.1.0";
-          src = ./.;
-
-          nativeBuildInputs = [ pkgs.cmake pkgs.pkg-config ];
-          buildInputs = with pkgs; [
-            ncurses
-            SDL2
-            libGL
-            xorg.libX11
-          ];
-
-          cmakeFlags = [
-            "-DBUILD_GUI=ON"
-            "-DCURSES_NEED_NCURSES=TRUE"
-            "-DCURSES_NEED_WIDE=TRUE"
-          ];
-
-          # Alternative (even stronger): completely hide the broken module
-          preConfigure = ''
-            # If the project ships its own FindSDL2.cmake in cmake/, hide it
-            if [ -f cmake/FindSDL2.cmake ]; then
-              mv cmake/FindSDL2.cmake cmake/FindSDL2.cmake.disabled
-              echo "Disabled bundled FindSDL2.cmake"
-            fi
-          '';
-
-          meta = with pkgs.lib; {
-            description = "kte  ImGui/SDL2 GUI editor";
-            mainProgram = "kte";
-            platforms = platforms.linux;
-          };
-        };
-
-        devShells.default = pkgs.mkShell {
-          inputsFrom = [ self.packages.${system}.default ];
-          packages = with pkgs; [ gdb clang-tools ];
-        };
-      });
-}
--- a/flake.lock
+++ b/flake.lock
@@ -2,15 +2,15 @@
  "nodes": {
    "nixpkgs": {
      "locked": {
-        "lastModified": 1764242076,
-        "narHash": "sha256-sKoIWfnijJ0+9e4wRvIgm/HgE27bzwQxcEmo2J/gNpI=",
-        "owner": "nixos",
+        "lastModified": 1764517877,
+        "narHash": "sha256-pp3uT4hHijIC8JUK5MEqeAWmParJrgBVzHLNfJDZxg4=",
+        "owner": "NixOS",
        "repo": "nixpkgs",
-        "rev": "2fad6eac6077f03fe109c4d4eb171cf96791faa4",
+        "rev": "2d293cbfa5a793b4c50d17c05ef9e385b90edf6c",
        "type": "github"
      },
      "original": {
-        "owner": "nixos",
+        "owner": "NixOS",
        "ref": "nixos-unstable",
        "repo": "nixpkgs",
        "type": "github"
--- a/flake.nix
+++ b/flake.nix
@@ -1,21 +1,20 @@
 {
-  description = "Kyle's Text Editor";
+  description = "kyle's text editor";

-  inputs = {
-    nixpkgs.url = "github:nixos/nixpkgs?ref=nixos-unstable";
-  };
+  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";

  outputs =
-    { self, nixpkgs }:
+    inputs@{ self, nixpkgs, ... }:
    let
-      pkgs = import nixpkgs { system = "x86_64-linux"; };
+      eachSystem = nixpkgs.lib.genAttrs nixpkgs.lib.systems.flakeExposed;
+      pkgsFor = system: import nixpkgs { inherit system; };
    in
    {
-      packages.x86_64-linux = {
-        default = pkgs.callPackage ./default-nogui.nix { };
-        kge     = pkgs.callPackage ./default-gui.nix   { };
-        kte     = pkgs.callPackage ./default-nogui.nix { };
-        full    = pkgs.callPackage ./default.nix       { };
-      };
+      packages = eachSystem (system: rec {
+        default = kte;
+        full = kge;
+        kte = (pkgsFor system).callPackage ./default.nix { graphical = false; };
+        kge = (pkgsFor system).callPackage ./default.nix { graphical = true; };
+      });
    };
 }
--- a/kge.icns
+++ b/kge.icns
--- a/kge.iconset/icon_128x128.png
+++ b/kge.iconset/icon_128x128.png
--- a/kge.iconset/icon_128x128@2x.png
+++ b/kge.iconset/icon_128x128@2x.png
--- a/kge.iconset/icon_16x16.png
+++ b/kge.iconset/icon_16x16.png
--- a/kge.iconset/icon_16x16@2x.png
+++ b/kge.iconset/icon_16x16@2x.png
--- a/kge.iconset/icon_256x256.png
+++ b/kge.iconset/icon_256x256.png
--- a/kge.iconset/icon_256x256@2x.png
+++ b/kge.iconset/icon_256x256@2x.png
--- a/kge.iconset/icon_32x32.png
+++ b/kge.iconset/icon_32x32.png
--- a/kge.iconset/icon_32x32@2x.png
+++ b/kge.iconset/icon_32x32@2x.png
--- a/kge.iconset/icon_512x512.png
+++ b/kge.iconset/icon_512x512.png
--- a/kge.iconset/icon_512x512@2x.png
+++ b/kge.iconset/icon_512x512@2x.png
--- a/kge.png
+++ b/kge.png
--- a/main.cc
+++ b/main.cc
@@ -1,15 +1,15 @@
+#include <cctype>
+#include <cstdio>
+#include <getopt.h>
 #include <iostream>
 #include <memory>
-#include <string>
-#include <cctype>
-#include <unistd.h>
-#include <getopt.h>
 #include <signal.h>
-#include <cstdio>
+#include <string>
+#include <unistd.h>
 #include <sys/stat.h>

-#include "Editor.h"
 #include "Command.h"
+#include "Editor.h"
 #include "Frontend.h"
 #include "TerminalFrontend.h"

@@ -22,6 +22,7 @@
 #  define KTE_VERSION_STR "devel"
 #endif

+
 static void
 PrintUsage(const char *prog)
 {
--- a/test_undo.cc
+++ b/test_undo.cc
@@ -1,10 +1,11 @@
-#include <iostream>
 #include <cassert>
 #include <fstream>
+#include <iostream>
+
+#include "Buffer.h"
+#include "Command.h"
 #include "Editor.h"
 #include "TestFrontend.h"
-#include "Command.h"
-#include "Buffer.h"


 int
@@ -93,6 +94,241 @@ main()
 	std::cout << "  Buffer content: '" << line_after_redo << "'\n";
 	std::cout << "  ✓ Redo successful - text restored\n\n";

+	// Test 4: Branching behavior – redo is discarded after new edits
+	std::cout << "Test 4: Branching behavior (redo discarded after new edits)\n";
+	// Reset to empty by undoing the last redo and the original insert, then reinsert 'abc'
+	// Ensure buffer is empty before starting this scenario
+	frontend.Input().QueueCommand(CommandId::Undo); // undo Hello
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]) == "");
+
+	// Type a contiguous word 'abc' (single batch)
+	frontend.Input().QueueText("abc");
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]) == "abc");
+
+	// Undo once – should remove the whole batch and leave empty
+	frontend.Input().QueueCommand(CommandId::Undo);
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]) == "");
+
+	// Now type new text 'X' – this should create a new branch and discard old redo chain
+	frontend.Input().QueueText("X");
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]) == "X");
+
+	// Attempt Redo – should be a no-op (redo branch was discarded by new edit)
+	frontend.Input().QueueCommand(CommandId::Redo);
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]) == "X");
+	// Undo and Redo along the new branch should still work
+	frontend.Input().QueueCommand(CommandId::Undo);
+	frontend.Input().QueueCommand(CommandId::Redo);
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]) == "X");
+	std::cout << "  ✓ Redo discarded after new edit; new branch undo/redo works\n\n";
+
+	// Clear buffer state for next tests: undo to empty if needed
+	frontend.Input().QueueCommand(CommandId::Undo);
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]) == "");
+
+	// Test 5: UTF-8 insertion and undo/redo round-trip
+	std::cout << "Test 5: UTF-8 insertion 'é漢' and undo/redo\n";
+	const std::string utf8_text = "é漢"; // multi-byte UTF-8 (2 bytes + 3 bytes)
+	frontend.Input().QueueText(utf8_text);
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]) == utf8_text);
+	// Undo should remove the entire contiguous insertion batch
+	frontend.Input().QueueCommand(CommandId::Undo);
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]) == "");
+	// Redo restores it
+	frontend.Input().QueueCommand(CommandId::Redo);
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]) == utf8_text);
+	std::cout << "  ✓ UTF-8 insert round-trips with undo/redo\n\n";
+
+	// Clear for next test
+	frontend.Input().QueueCommand(CommandId::Undo);
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]) == "");
+
+	// Test 6: Multi-line operations (newline split and join via backspace at BOL)
+	std::cout << "Test 6: Newline split and join via backspace at BOL\n";
+	// Insert "ab" then newline then "cd" → expect two lines
+	frontend.Input().QueueText("ab");
+	frontend.Input().QueueCommand(CommandId::Newline);
+	frontend.Input().QueueText("cd");
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(buf->Rows().size() >= 2);
+	assert(std::string(buf->Rows()[0]) == "ab");
+	assert(std::string(buf->Rows()[1]) == "cd");
+	std::cout << "  ✓ Split into two lines\n";
+
+	// Undo once – should remove "cd" insertion leaving two lines ["ab", ""] or join depending on commit
+	frontend.Input().QueueCommand(CommandId::Undo);
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	// Current design batches typing on the second line; after undo, the second line should exist but be empty
+	assert(buf->Rows().size() >= 2);
+	assert(std::string(buf->Rows()[0]) == "ab");
+	assert(std::string(buf->Rows()[1]) == "");
+
+	// Undo the newline – should rejoin to a single line "ab"
+	frontend.Input().QueueCommand(CommandId::Undo);
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(buf->Rows().size() >= 1);
+	assert(std::string(buf->Rows()[0]) == "ab");
+
+	// Redo twice to get back to ["ab","cd"]
+	frontend.Input().QueueCommand(CommandId::Redo);
+	frontend.Input().QueueCommand(CommandId::Redo);
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]) == "ab");
+	assert(std::string(buf->Rows()[1]) == "cd");
+	std::cout << "  ✓ Newline undo/redo round-trip\n";
+
+	// Now join via Backspace at beginning of second line
+	frontend.Input().QueueCommand(CommandId::MoveDown); // ensure we're on the second line
+	frontend.Input().QueueCommand(CommandId::MoveHome); // go to BOL on second line
+	frontend.Input().QueueCommand(CommandId::Backspace); // join with previous line
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(buf->Rows().size() >= 1);
+	assert(std::string(buf->Rows()[0]) == "abcd");
+	std::cout << "  ✓ Backspace at BOL joins lines\n";
+
+	// Undo/Redo the join
+	frontend.Input().QueueCommand(CommandId::Undo);
+	frontend.Input().QueueCommand(CommandId::Redo);
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(buf->Rows().size() >= 1);
+	assert(std::string(buf->Rows()[0]) == "abcd");
+	std::cout << "  ✓ Join undo/redo round-trip\n\n";
+
+	// Test 7: Typing batching – a contiguous word undone in one step
+	std::cout << "Test 7: Typing batching (single undo removes whole word)\n";
+	// Clear current line first
+	frontend.Input().QueueCommand(CommandId::MoveHome);
+	frontend.Input().QueueCommand(CommandId::KillToEOL);
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]).empty());
+	// Type a word and verify one undo clears it
+	frontend.Input().QueueText("hello");
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]) == "hello");
+	frontend.Input().QueueCommand(CommandId::Undo);
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]).empty());
+	frontend.Input().QueueCommand(CommandId::Redo);
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]) == "hello");
+	std::cout << "  ✓ Contiguous typing batched into single undo step\n\n";
+
+	// Test 8: Forward delete batching at a fixed anchor column
+	std::cout << "Test 8: Forward delete batching at fixed anchor (DeleteChar)\n";
+	// Prepare line content
+	frontend.Input().QueueCommand(CommandId::MoveHome);
+	frontend.Input().QueueCommand(CommandId::KillToEOL);
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	frontend.Input().QueueText("abcdef");
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	// Ensure cursor at anchor column 0
+	frontend.Input().QueueCommand(CommandId::MoveHome);
+	// Delete three chars at cursor; should batch into one Delete node
+	frontend.Input().QueueCommand(CommandId::DeleteChar, "", 3);
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]) == "def");
+	// Single undo should restore the entire deleted run
+	frontend.Input().QueueCommand(CommandId::Undo);
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]) == "abcdef");
+	// Redo should remove the same run again
+	frontend.Input().QueueCommand(CommandId::Redo);
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]) == "def");
+	std::cout << "  ✓ Forward delete batched and undo/redo round-trips\n\n";
+
+	// Test 9: Backspace batching with prepend rule (cursor moves left)
+	std::cout << "Test 9: Backspace batching with prepend rule\n";
+	// Restore to full string then backspace a run
+	frontend.Input().QueueCommand(CommandId::Undo); // bring back to "abcdef"
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]) == "abcdef");
+	// Move to end and backspace three characters; should batch into one Delete node
+	frontend.Input().QueueCommand(CommandId::MoveEnd);
+	frontend.Input().QueueCommand(CommandId::Backspace, "", 3);
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]) == "abc");
+	// Single undo restores the deleted run
+	frontend.Input().QueueCommand(CommandId::Undo);
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]) == "abcdef");
+	// Redo removes it again
+	frontend.Input().QueueCommand(CommandId::Redo);
+	while (!frontend.Input().IsEmpty() && running) {
+		frontend.Step(editor, running);
+	}
+	assert(std::string(buf->Rows()[0]) == "abc");
+	std::cout << "  ✓ Backspace run batched and undo/redo round-trips\n\n";
+
 	frontend.Shutdown();

 	std::cout << "====================================\n";
Author	SHA1	Message	Date
Kyle Isom	1892075d82	bump version Some checks failed Release / Bump Homebrew formula (push) Has been cancelled Release / Build Linux amd64 (push) Has been cancelled Release / Build Linux arm64 (push) Has been cancelled Release / Build macOS arm64 (.app) (push) Has been cancelled Release / Create GitHub Release (push) Has been cancelled	2025-12-01 16:38:10 -08:00
Kyle Isom	719862c842	Fix double scroll issue.	2025-12-01 16:37:51 -08:00
Kyle Isom	655cc40162	Refine help text, keybindings, GUI themes, and undo system. Some checks failed Release / Bump Homebrew formula (push) Has been cancelled Release / Build Linux amd64 (push) Has been cancelled Release / Build Linux arm64 (push) Has been cancelled Release / Build macOS arm64 (.app) (push) Has been cancelled Release / Create GitHub Release (push) Has been cancelled - Expanded help text and command documentation with detailed keybinding descriptions. - Added theme customization support to GUIConfig (Nord default, light/dark variants). - Adjusted for consistent indentation and debug instrumentation in undo system. - Enhanced test cases for multi-line, UTF-8, and branching scenarios.	2025-12-01 15:21:52 -08:00
Kyle Isom	d98785e825	bump Some checks failed Release / Bump Homebrew formula (push) Has been cancelled Release / Build Linux amd64 (push) Has been cancelled Release / Build Linux arm64 (push) Has been cancelled Release / Build macOS arm64 (.app) (push) Has been cancelled Release / Create GitHub Release (push) Has been cancelled	2025-12-01 12:00:52 -08:00
Kyle Isom	970a31e0d9	Add Nord theme for real	2025-12-01 12:00:10 -08:00
Kyle Isom	464ad8d1ae	Nord theme and undo system refinements - Improve text input/event batching - Enhance debugging with optional instrumentation - Begin implementation of non-linear undo tree structure.	2025-12-01 11:59:51 -08:00
Kyle Isom	0cb7d36f2a	bump version Some checks failed Release / Bump Homebrew formula (push) Has been cancelled Release / Build Linux amd64 (push) Has been cancelled Release / Build Linux arm64 (push) Has been cancelled Release / Build macOS arm64 (.app) (push) Has been cancelled Release / Create GitHub Release (push) Has been cancelled	2025-12-01 11:22:47 -08:00
Kyle Isom	09a6df0c33	Add regex search, search/replace, and buffer read-only mode functionality with help text	2025-12-01 02:54:40 -08:00
Kyle Isom	69457c424c	add regex and search/replace functionality to editor	2025-11-30 23:33:17 -08:00
Kyle Isom	24c8040d8a	trash flake-gui	2025-11-30 22:02:43 -08:00
Kyle Isom	e869249a7c	thaaaaanks jeremy	2025-11-30 22:02:23 -08:00
Kyle Isom	35e957b326	Fix void crash in kge. Some checks failed Release / Bump Homebrew formula (push) Has been cancelled Release / Build Linux amd64 (push) Has been cancelled Release / Build Linux arm64 (push) Has been cancelled Release / Build macOS arm64 (.app) (push) Has been cancelled Release / Create GitHub Release (push) Has been cancelled	2025-11-30 21:51:03 -08:00
Kyle Isom	e7eb35626c	NixOS build	2025-11-30 21:07:41 -08:00
Kyle Isom	f9128a336d	better support for smaller screens Some checks failed Release / Bump Homebrew formula (push) Has been cancelled Release / Build Linux amd64 (push) Has been cancelled Release / Build Linux arm64 (push) Has been cancelled Release / Build macOS arm64 (.app) (push) Has been cancelled Release / Create GitHub Release (push) Has been cancelled editor_prompt should replace the status line when active	2025-11-30 20:25:53 -08:00
Kyle Isom	f8d0e9213f	bump version Some checks failed Release / Bump Homebrew formula (push) Has been cancelled Release / Build Linux amd64 (push) Has been cancelled Release / Build Linux arm64 (push) Has been cancelled Release / Build macOS arm64 (.app) (push) Has been cancelled Release / Create GitHub Release (push) Has been cancelled Also add some TODOs.	2025-11-30 19:57:05 -08:00
Kyle Isom	68286ecb7c	Add icon to share/icons for Linux.	2025-11-30 19:55:03 -08:00
Kyle Isom	44807d0f40	clang-tidy was zealous on macOS.	2025-11-30 19:47:43 -08:00
Kyle Isom	41f37478c1	bump cmake version Some checks failed Release / Bump Homebrew formula (push) Has been cancelled Release / Build Linux amd64 (push) Has been cancelled Release / Build Linux arm64 (push) Has been cancelled Release / Build macOS arm64 (.app) (push) Has been cancelled Release / Create GitHub Release (push) Has been cancelled	2025-11-30 19:09:35 -08:00
Kyle Isom	d582979eb3	release maybe	2025-11-30 19:08:34 -08:00
Kyle Isom	2b194c7910	Actually add the screenshot.	2025-11-30 18:55:55 -08:00
Kyle Isom	6498213378	updating readme and roadmap	2025-11-30 18:54:24 -08:00
Kyle Isom	1a37a92534	add screenshot to README	2025-11-30 18:45:11 -08:00
Kyle Isom	fb5976f123	Add buffer position display and documentation improvements. Some checks failed Release / Bump Homebrew formula (push) Has been cancelled - Display buffer position prefix "[x/N]" in GUI and terminal renderers. - Improve `kte` and `kge` man pages with frontend usage details and project homepage. - Update README with GUI invocation instructions. - Bump version to 1.0.0.	2025-11-30 18:40:44 -08:00
Kyle Isom	e4cd4877cc	Introduce file picker and GUI configuration with enhancements. - Add visual file picker for GUI with toggle support. - Introduce `GUIConfig` class for loading GUI settings from configuration file. - Refactor window initialization to support dynamic sizing based on configuration. - Add macOS-specific handling for fullscreen behavior. - Improve header inclusion order and minor code cleanup.	2025-11-30 18:35:12 -08:00