pavel/editor
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
editor/ROADMAP.md
pavel 985aa16236 j
2026-07-09 08:27:13 +02:00

9.5 KiB
Raw Permalink Blame History

Native Kotlin Editor Roadmap

Current State

  • Odin editor core with piece-table storage.
  • File-backed editor buffers.
  • Cursor movement and line/column mapping.
  • SDL3 native window mode.
  • SDL3 GPU command-buffer renderer path when a GPU backend is available.
  • Basic text input, Enter with auto-indent, Backspace, Delete, Tab indent, arrows, Ctrl+Left/Ctrl+Right, selection, mouse click/drag cursor placement, and Ctrl+S save.
  • JVM daemon over TCP JSON-lines.
  • Gradle workspace import via Tooling API.
  • Kotlin diagnostics using compiler embeddable.
  • Async diagnostics/publish events rendered in the SDL gutter/status area and stored by file path for open buffers.

Phase 1: Usable Editor

  • Open arbitrary files in SDL mode.
  • Add project file tree. Done.
  • Support multiple open buffers.
  • Add proper viewport scrolling independent of cursor.
  • Add PageUp/PageDown/Home/End.
  • Add Ctrl+Left/Ctrl+Right word movement. Done.
  • Add mouse wheel scrolling.
  • Add click-to-move-cursor. Done.
  • Add mouse drag selection. Done.
  • Add undo/redo.
  • Add selection. Done.
  • Add copy/cut/paste. Done.
  • Add Delete key. Done.
  • Add Tab/indent/outdent. Done: Tab inserts four spaces and Shift+Tab outdents the current or selected lines.
  • Add auto-indent on Enter. Done.
  • Add search in file. Started: Ctrl+F find panel with next/previous navigation and visible match highlights.
  • Add Save All. Done.
  • Replace SDL debug text with proper font rendering. Started: direct GPU path uses an stb_truetype baked Noto Sans Mono atlas.
  • Replace renderer-backed drawing with a direct SDL3 GPU command-buffer quad/text pipeline. Started: rectangles, lines, panels, selection, cursor, and temporary text render through SDL3 GPU with SDL renderer fallback.
  • Add shader compilation pipeline. Started: GLSL sources plus scripts/compile-shaders.sh using glslc to emit SPIR-V.
  • Add syntax highlighting. Started: lightweight visible-line Kotlin/Java tokenizer in the GPU renderer.

Phase 2: Daemon Integration

  • Start JVM daemon automatically from Odin. Done.
  • Read daemon PORT from stdout. Done.
  • Stop daemon on editor exit. Done.
  • Restart daemon if it crashes. Done for auto-started SDL daemons; explicit external-port mode reports disconnects without spawning a replacement.
  • Replace ad-hoc JSON parsing in Odin. Done.
  • Track request IDs and pending responses. Done.
  • Distinguish responses and events cleanly. Done.
  • Store diagnostics per file, not only active file. Done: diagnostics events are queued and applied to the matching open buffer path.
  • Clear stale diagnostics on workspace reload.
  • Render diagnostic underlines/squiggles. Started: GPU renderer draws red dashed underlines on diagnostic lines.
  • Add next/previous diagnostic navigation. Done: F8 and Shift+F8 navigate active-file diagnostics.
  • Add diagnostics panel. Done: Ctrl+Shift+M opens active-file diagnostics with keyboard navigation.
  • Show Gradle tasks in UI. Started: Ctrl+Shift+T requests and displays tasks in a docked GPU right sidebar; responses are matched by request id.
  • Run selected Gradle task. Started: Enter in the Gradle tasks panel runs the selected task and reports success/failure.
  • Stream Gradle task output. Started: Gradle run lifecycle and stdout/stderr line events are surfaced in the tasks sidebar with recent output retained.
  • Add workspace reload/import action. Started: command palette Reload Workspace refreshes the file tree, sends workspace/open, clears stale diagnostics, and resyncs the active buffer.

Phase 3: Kotlin And Java Intelligence

  • Implement kotlin/completion in the daemon. Started: prefix-filtered Kotlin keywords plus heuristic current-buffer/workspace identifiers and declarations.
  • Add completion popup in SDL UI. Done: popup renders returned items and applies the selected completion with Enter or row click, using a single undoable replace edit.
  • Add keyboard navigation in completion popup. Done.
  • Implement kotlin/hover. Started: Kotlin Analysis API symbol resolution with heuristic declaration fallback.
  • Render hover tooltip. Done.
  • Implement kotlin/definition. Started: Kotlin Analysis API symbol resolution with heuristic declaration fallback.
  • Open target file and jump to line/column. Done.
  • Add back/forward navigation stack. Done.
  • Add find references. Started: Kotlin Analysis API symbol matching with heuristic source-scan fallback and SDL references popup.
  • Add rename/refactor support. Started: daemon preview-only rename edits with SDL preview panel.
  • Add Java diagnostics/completion/navigation. Started: .java diagnostics use the JDK compiler with Gradle module classpath/sourcepath; completion/hover/definition/references scan Java source declarations heuristically.

Phase 4: Backend Quality

  • Replace compiler-per-request diagnostics with long-lived analysis state.
  • Cache Gradle module classpaths and source roots.
  • Move toward Kotlin Analysis API where feasible. Started: definition, hover, and references use standalone Kotlin Analysis API before heuristic fallback.
  • Correctly model multi-module projects. Started: diagnostics choose the module with the most specific matching source root.
  • Separate main/test source-set analysis. Started: diagnostics use main roots for main files and main+test roots for test files.
  • Include generated sources. Started: common existing build/generated/ Kotlin/Java roots, including KSP/Kotlin Multiplatform source-set layouts, are added to Gradle module source roots.
  • Improve classpath and project dependency handling. Started: diagnostics include existing module output directories from build/classes/ and build/resources/, including common JVM/KMP layouts; Kotlin diagnostics include Java sources from the matching Gradle source roots.

Phase 5: Product Shape

  • Add sidebar file tree.
  • Add editor tabs. Done: GPU tab strip shows open buffers and supports click-to-switch, close buttons, and drag reorder.
  • Add bottom panel for diagnostics/tasks/output.
  • Add command palette. Started: Ctrl+Shift+P opens a filterable GPU command palette for existing editor actions.
  • Add configurable keybindings.
  • Add theme settings.
  • Add font settings.
  • Persist last workspace, open files, cursor positions, and window layout. Started: window size, sidebars, open files, active tab, and cursor offsets are cached per workspace.

Performance Work

  • Incrementally update line index.
  • Compact piece table after many edits.
  • Cache rendered text/glyphs.
  • Avoid full-buffer text/change sync on every edit. Started: edit-triggered sync is debounced.
  • Debounce native-to-daemon text sync. Done: text edits schedule a delayed sync; file open/switch/navigation and daemon-backed commands still flush immediately.

Next Work Queue

  1. Open arbitrary file from SDL mode. Done.
  2. Add scrolling/PageUp/PageDown/Home/End. Done.
  3. Add undo/redo. Done.
  4. Add daemon auto-start. Done.
  5. Add robust protocol parser. Done.
  6. Add project file tree. Done.
  7. Add completion popup skeleton. Done.
  8. Wire completion responses into popup. Done.
  9. Implement real kotlin/completion in the daemon. Started: prefix-filtered Kotlin keywords plus heuristic current-buffer/workspace identifiers and declarations.
  10. Implement kotlin/hover and render hover tooltip. Started: Kotlin Analysis API symbol resolution with heuristic declaration fallback.
  11. Implement kotlin/definition and Ctrl+B navigation. Started: Kotlin Analysis API symbol resolution with heuristic declaration fallback.
  12. Add back/forward navigation stack. Done.
  13. Add find references. Started: Kotlin Analysis API symbol matching with heuristic source-scan fallback and SDL references popup.
  14. Add rename/refactor support. Started: daemon preview-only rename edits with SDL preview panel.
  15. Add Ctrl+Left/Ctrl+Right word movement. Done.
  16. Add click-to-move-cursor. Done.
  17. Add Delete key. Done.
  18. Add Tab indentation and auto-indent. Done: Tab inserts four spaces, Shift+Tab outdents, and Enter preserves leading whitespace.
  19. Improve mouse support. Done: sidebar/editor wheel routing, sidebar scrolling, click-to-place-cursor, drag selection.
  20. Add selection. Done: mouse drag and Shift+movement selection with replacement on edit.

Immediate Stabilization Goals

  1. Text metrics correctness. In progress: GPU text uses explicit fixed-cell atlas placement, widened cell advance, GPU-aware hit-testing, and Ctrl+M metrics overlay.
  2. Font portability. Done for the prototype: bundled Noto Sans Mono is loaded from client/odin/assets/fonts/ with system fallback paths.
  3. Proper font shaping baseline. Replace baked ASCII-only atlas with a more deliberate atlas/SDF pipeline.
  4. Renderer abstraction cleanup. Split UI drawing from SDL fallback/GPU backend details.
  5. Input consistency. Started: cursor, hit-testing, syntax spans, and selection use shared metrics in the GPU path; command palette, completion, references, diagnostics, and Gradle panels now keep keyboard selection visible, support row clicks, route wheel events when hovered, and handle PageUp/PageDown plus Home/End.
  6. Syntax quality. Started: visible-line tokenizer now carries /* ... */ block comment and Kotlin triple-quoted string state across rendered lines, with Kotlin/Java keywords and character literals. Still needs semantic tokens.
  7. Editor essentials. Done for the current prototype: clipboard copy/cut/paste, Save All, richer Ctrl+F search, clickable GPU tabs, safe Ctrl+W tab close, tab close buttons, drag reorder, stale overlay cleanup after edits, dirty tracking by saved buffer version, robust open-buffer diagnostic matching, and single-step/no-op-aware undo for selection/full-buffer replacement are implemented.