Settings page now mirrors the legacy shell's layout: left section nav (Appearance / Profiles / Providers / SSH / Network / Interaction / Keymap / Advanced / Backup, same names and order as NebulaSettingsSection) with single-section content on the right. nebula-settings grows the full key-value surface ported verbatim from nebula_settings_load - language, shell, startup_directory, ghost/accept/completion_style, cjk_bold_regular, tab_reveal, density, new_tab_position, cell_width_mode, fetch, keep_session, restore_session, resume_ai, tray, blur, opacity, background (hex), panel_resize, ssh proxy trio, quick_terminal_hotkey - with factory defaults asserted item-by-item in tests (9 passing). Fixes a real unit bug: the font_size key stores LOGICAL PIXELS (legacy persists size/scale), not points - the GPUI shell was multiplying by 4/3 and rendering every terminal a third too large. Editors that depend on unmigrated subsystems (keymap table, SSH hosts, AI providers, backup) show explicit placeholders pointing at the legacy page; both shells keep reading and writing the same nebula_settings.txt.
First product-facing settings surface in the GPUI shell, kept strictly as a thin view: every semantic (keys, value domains, theme tables, persistence format) lives in the shared nebula-settings crate that was ported verbatim from the legacy shell. The pane edits theme / font size / cursor shape / cursor blink / copy-on-select / powerline via library Select/Checkbox/Button components and writes back through the new persist_keys (in-place key replacement preserving line order, unknown keys and comments - 3 new unit tests, 8/8 passing), so both shells keep reading the same nebula_settings.txt. Changes hot-apply: the workspace re-derives global Settings, pushes palette/font-size/fonts/copy_on_select into every open terminal view and re-syncs window chrome light/dark to the theme; cursor shape and font family take effect for new tabs, matching the legacy semantics. Entry points: titlebar gear button, Ctrl+comma, singleton settings tab in the sidebar.
Physically relocates the validated GPUI surface out of the lab crate into nebula_app/src/gpui_shell/ (git mv keeps history): the terminal stack (view/element/session/keymap/mouse_protocol/colors), the config bridge (nebula.toml + nebula_settings.txt + theme tables), the workspace view and the theme/prelude glue. Per product ruling, nebula_gpui is a scratch lab - it keeps only the component gallery (terminal preview removed) plus annotated copies of theme/prelude, and its Cargo manifest drops the terminal/settings dependencies. The gpui-shell feature is now self-contained: nebula depends directly on gpui/gpui-component/-assets (redirected to our fork by the root patch table), nebula-settings and futures; the nebula-gpui crate dependency is gone. Entry points: 'nebula --gpui' runs the GPUI main-window form on the main thread with winit never starting (P3 acceptance form; gates get re-measured here), and the NEBULA_GPUI_SHELL=1 dedicated-thread spike stays until the P3 takeover completes. Verified: cargo check on both crates, and nebula --gpui opens the Nebula main window with working tabs, ConPTY terminal, CJK text and powerline prompt (screenshot .tmp_parity_gpui-in-nebula.png).
Extracts the split-pane rules from the legacy shell's window_context/split.rs into a zero-dependency workspace crate: the layout tree (split/remove/collapse, path addressing), the geometry pass (floor + per-side cell clamping, divider rects with tree paths), divider drag rules (unclamped pointer ratio, preview pinning in the close zone, drag-to-close margins, whole-cell commit quantization) and directional focus (4x perpendicular-drift penalty). Math ported verbatim and locked by 12 unit tests. The legacy implementation stays frozen in-tree per the P4 ruling; the GPUI layer inside nebula_app is the intended consumer.
- completion: switchable inline ghost vs popup candidate list (history /
frecency dirs / PATH commands / files, Up/Down + accept key + Esc);
settings dropdown, palette action, persisted as completion_style
- settings: real HSV picker in the background-color popup (SV plane + hue
bar, drag picks live, release persists); presets and hex stay in sync
- paste: image-only clipboard pastes a PNG path - local temp file, or SFTP
upload to remote /tmp with the path typed back so
codex/claude receive usable image paths on both sides
- fix: Explorer context-menu launches attach the resident instance and open
a cwd tab (tab.new gains optional cwd) instead of a lone fresh window
- fix: default-shell dropdown hit-test counts imported profiles, making the
trailing rows selectable again
- fix: git drawer works on dubious-ownership roots (wsl$ UNC, elevated) via
per-invocation safe.directory; failures now logged instead of silent blank
- deps: gpui/gpui-component redirected to Kuddev forks pinned at the
published base revs (patch playbook in the root manifest)
- wire the in-flight resume_ai toggle (display field, toggle, persistence)
so the parallel session-restore work builds and tests stay green
Mouse-mode apps (vim/htop) now own the pointer: press/release/drag/motion/wheel are encoded per protocol (SGR, normal, UTF-8 extension) and reported to the app, with Shift as the local-selection escape hatch - same as the legacy shell. The encoder is a pure module ported verbatim from input/mouse.rs with unit tests locking the byte sequences. Right-click follows the legacy Windows convention (copy+clear when a selection exists, paste otherwise), copy_on_select fires on release, Shift+click extends an existing selection, and Shift+PageUp/PageDown/Home/End page the scrollback on the primary screen.
New zero-dependency workspace crate owning nebula_settings.txt path resolution, key semantics and the per-theme terminal color tables (background, light-theme foreground/ANSI-16 replacement, powerline slots 16..=23) - values transcribed verbatim from the legacy shell's theme.rs, which stays frozen per P4. The GPUI lab now honors the user's actual runtime intent: theme (SilverLight etc.) applied over toml colors in the same order as apply_term_colors, font family/size from the settings UI, default cursor shape/blink wired into the engine Term config, copy_on_select exposed for the next slice. Cargo.lock intentionally not committed: it currently carries the user's in-flight gpui-fork switch.
Discriminating experiments: legacy shell forced to in-box ConPTY (openconsole=off) runs the 50MB payload in 38-94s (0.5-1.3 MB/s, huge variance); the GPUI lab without the sideloaded pair completes in 84s. Both shells degrade identically, so the earlier stall diagnosis is corrected: no engine deadlock, nothing to fix engine-side. Deploying the OpenConsole/conpty.dll pair next to any nebula-family exe stays a hard ops rule.
One-page hand-verification list for the Chinese IME gate: preedit anchoring, candidate window tracking, commit/cancel/backspace paths, scrolling during composition, TUI anchoring, focus/tab/DPI interactions. Any failing item vetoes G2.
Fixed sample sheet (boxdraw families, blocks/shades/quadrants/sextants, Powerline separators, CJK alignment ruler, 256/truecolor bars) injected via the focus-free ConPTY injector, captured with PrintWindow PW_RENDERFULLCONTENT. First pass: structural parity across the board - boxes closed and seamless, CJK ruler column-aligned, Powerline triangles crisper on the GPUI side thanks to boxdraw geometry. Follow-ups: same-theme comparison after config sharing, real fastfetch once installed, zoomed stroke-weight audit.
Payload mixes ANSI 256/truecolor, CJK, boxdraw and Powerline lines; timing happens inside the session (stopwatch around cmd /c type) so only PTY-consumption speed is measured. Commands are injected via AttachConsole + WriteConsoleInputW - no window focus involved - and the window is made topmost without activation so both shells actually render (the legacy renderer skips frames when fully occluded). First results: gpui-lab within 3.6 pct of winit-old throughput (21.8s vs 21.1s per 50MB) at 28 pct less memory; G1 threshold set at 90 pct on an equal grid. Also caught a real engine bug: the system-conhost ConPTY fallback (no sideloaded OpenConsole/conpty.dll pair) stalls completely under sustained output; fix scheduled in P2.
Final form pinned per product decision: one product and one codebase (nebula.exe / nebula_app) with GPUI as its in-process UI layer; nebula_gpui is a validation lab whose proven modules get integrated into nebula_app, never a second product. Grid rendering stays first-party via the render contract; powerline/fastfetch/CJK fidelity are acceptance gates. Mega-file split (display/mod.rs 10k+ lines etc.) is scheduled as a dedicated refactor pass after GPUI integration.
Port nebula_app's builtin_font coverage (box drawing, block elements, legacy sextants/blocks, Powerline separators) from pixel rasterization to renderer-agnostic fill primitives: axis-aligned rects plus convex polygons, snapped to device pixels so strokes stay crisp and join seamlessly across cells. RenderSnapshot::capture now routes these cells to box_glyphs instead of text segments - the typography engine never touches them, which roots out the box-line misalignment CJK fonts cause. The GPUI element consumes the primitives via paint_quad/paint_path (cursor inversion rules unchanged). Known deltas vs the legacy rasterizer: narrow-cell Powerline tips clip instead of falling back to the font, and shade blocks use alpha 64/128/192. Engine tests: 202 passing (11 new).
Per product decision: once GPUI genuinely beats the hand-drawn UI for a surface, it becomes that surface's code path outright - no runtime switches or long-lived feature flags keeping two UI paths alive. Rollback = the winit shell and existing modules staying buildable in-tree, plus per-step commits to revert. The gpui-shell cargo feature is spike scaffolding slated for removal, not a rollback mechanism.
nebula_gpui now exposes run_shell() as a library entry so nebula.exe can
host the GPUI UI layer on a dedicated thread (route C: one program, GPUI
provides the component layer). The standalone bin remains for development.
Off by default; enabled via the gpui-shell feature + NEBULA_GPUI_SHELL=1.
Layering: Term (model) -> render contract -> frontend backend.
- CellMetrics + TerminalViewport: floor division, minimum grid, exact
text-area pixels (cols x cell_width) for PTY/app reporting.
- ViewportTracker: resize coalescing, monotonic revisions (a stale resize
can never override a newer one), and pixel-only changes still reported
to the PTY even when rows/cols are unchanged.
- RenderSnapshot: single-lock plain-data capture (bg runs, selection runs,
wide-aware text segments, cursor, OSC color-override copy). Colors stay
as vte values; frontends resolve them outside the lock.
- gpui element/view now consume the contract: grid math single-sourced in
the tracker, cursor-cell isolation for block-cursor inversion. Swapping
the paint backend later touches element.rs only.
- 6 contract tests (segmentation, cursor isolation, viewport rules).
Engine-side work from today's session: renderable_content_with_viewport /
viewport_origin_for crop the committed grid to the rows a deferred resize
will keep, so rendering during a drag and the settled reflow agree; grid
resize/row support included. Full engine suite green (191 tests).
- crossfont 0.8.1 -> 0.9.0: upstream bumped yeslogic-fontconfig-sys to ^6.0,
aligning with gpui's zed-font-kit so a single 6.0.1 owns links=fontconfig.
- wayland CSD switches to the ab_glyph flavor so sctk-adwaita 0.10 stops
pulling crossfont ^0.8 (and yeslogic ^5) back into the graph. Linux-only
decoration text; Windows/macOS unaffected.
- Drop the workspace exclude and nebula_gpui's member-level lockfile; one
lockfile now holds gpui 0.2.2 + crossfont 0.9.0. Both bins compile.
- ARCHITECTURE.md: the "unresolvable conflict" section now records the fix.
TerminalView now emits TitleChanged/Exited and owns session teardown
(Msg::Shutdown on removal, Drop as backstop). TerminalPanel adapts the
terminal to the dock Panel contract with a title_suffix close button,
since a root-level TabPanel never renders its own. NebulaWorkspace
wires TitleBar + tabs with ctrl-shift-t/w hotkeys (passed through the
terminal key handler), closes tabs on shell exit, and quits when the
last tab closes. The component gallery moves to a secondary window.
ConPTY + EventLoop wired through a futures channel into a GPUI entity;
custom Element paints the grid from a single-lock snapshot (bg runs,
force_width text segments for CJK alignment, cursor, selection); view
handles keyboard encoding, mouse selection, wheel scroll, clipboard,
and IME via EntityInputHandler. No fork of either side; boundary stays
symmetric (no GPUI types in nebula_terminal, no terminal types outside
src/terminal).
kuddev