Skip to content

ROADMAP.md

Latest commit

 

History

History
131 lines (96 loc) · 5.31 KB

ROADMAP.md

File metadata and controls

131 lines (96 loc) · 5.31 KB

Roadmap

Goal

Build a Windows-first file explorer that feels faster than Files by keeping the navigation hot path in Rust and using Tauri/Svelte as a thin desktop shell.

Reading Context

Strategy

  • Rust owns directory enumeration, sorting, filtering, search, file operations, archive handling, preview orchestration, caching, and job cancellation.
  • Tauri transports typed intents and incremental state updates.
  • Svelte renders panes, tabs, lists, path controls, menus, dialogs, and settings without owning filesystem logic.
  • Windows integrations live behind platform modules so future macOS/Linux support can share the core contracts.
  • Expensive enrichments stay off the navigation hot path and must be cancelable when they can race navigation.

Performance Budgets

  • Cold start to interactive shell: under 900 ms on a modern desktop.
  • Warm folder switch: first visible rows in under 100 ms.
  • Large folder navigation: incremental rows immediately, no UI freeze.
  • Sort on cached 10k-item directory: under 120 ms.
  • Details-view scrolling: stable 60 fps in virtualized lists.
  • Cancellation: stale navigation jobs never overwrite current view state.

Phase 0: Foundations

Goal: establish the repo and architecture boundary for a Rust-owned explorer.

  • Define Rust crate boundaries.
  • Define IPC around request ids, job ids, and streamed deltas for the first explorer slice.
  • Build benchmark harness for startup, navigation, search, sort, and file operations.
  • Lock down renderer-only frontend rules for the Tauri/Svelte shell.
  • Add docs, handbook, and ADR structure.

Phase 1: Fast Navigation Core

Goal: make local directory navigation fast, incremental, and stable.

  • Create Rust directory engine with Windows-first enumeration for the current single-pane explorer slice.
  • Return cheap item fields first and enrich later.
  • Add snapshot cache and cancellation-aware job scheduler.
  • Build a virtualized details view in Svelte.
  • Support basic selection, focus, keyboard navigation, and breadcrumbs.
  • Add Rust-owned in-folder filtering and sort specs.

Phase 2: Productivity Baseline

Goal: become useful as a daily-driver shell for common file work.

  • Add tabs.
  • Add rename, delete-to-recycle-bin, and create-folder actions.
  • Add dual-pane state model.
  • Add omnibar and command palette shell.
  • Add queued copy/move operations with progress and conflict handling.
  • Add developer settings for artificial navigation delay and UI testing toggles.
  • Add developer timing traces for navigation/render visibility.
  • Add persistent metrics collection for startup, navigation, sort, search, and scroll budgets.
  • Add native or shell-backed context menu flow.
  • Add full session restore across app restarts.

Phase 3: Rich File Workflows

Goal: add deeper file management without slowing the navigation hot path.

  • Add preview pane with lazy adapters.
  • Add archive browsing, extraction, and creation.
  • Add file properties and hashes.
  • Add advanced columns.
  • Add tags.
  • Add keyboard remapping.

Phase 4: Integrations

Goal: add optional external context behind explicit boundaries.

  • Add Git status and branch actions.
  • Add cloud drive providers without polluting core navigation latency.
  • Add FTP/SFTP.
  • Define third-party integration boundaries and plugin safety rules.
  • Add ADRs for integrations that touch credentials, shell execution, or the navigation hot path.

Phase 5: Future Portability

Goal: preserve Windows excellence while making future platform backends possible.

  • Extract remaining Windows assumptions into platform modules.
  • Add portable core tests.
  • Define platform backend contracts.
  • Introduce macOS/Linux backends only after Windows performance targets are consistently met.

Cross-Cutting Tracks

Safety and file operations:

  • Keep frontend filesystem behavior behind Tauri commands.
  • Keep first navigation slice Rust-owned.
  • Make destructive operations queue-aware and progress-reporting.
  • Prefer recycle-bin behavior where Windows supports it.
  • Add ADR before exposing broad shell execution or plugin execution.

UX and shell fidelity:

  • Match system light/dark theme by default.
  • Keep the main list virtualized.
  • Keep same-path refresh stable rather than clearing the list.
  • Add shell-native context menu behavior.
  • Add drag/drop affordances.
  • Add dual-pane workflows.

Agent and maintainer discipline:

  • Add docs index and agent guide.
  • Add engineering handbook.
  • Add architecture decision records directory.
  • Add checked-in pre-commit or validation hook if size/secrets checks need enforcement.
  • Keep roadmap/TODO items updated as milestones land.

Non-Negotiables

  • No large one-shot folder payloads.
  • No non-virtualized large lists.
  • No heavy metadata on first paint.
  • No UI-thread sorting for real directories.
  • No long-running integrations inline with navigation.
  • No frontend-owned filesystem operations.