Fresh

Fresh is a terminal-based text editor and IDE written in Rust that aims to eliminate the learning curve most terminal editors impose. Rather than adopting modal editing or asking users to memorize a new set of shortcuts, Fresh mirrors the keybindings, mouse support, menus, and command palette of graphical editors like VS Code and Sublime Text, so anyone can sit down and start editing immediately without touching a config file.

Under that familiar surface sits a genuinely capable editor: multi-cursor editing, split panes, an integrated terminal, a file explorer, and full Language Server Protocol support for go-to-definition, hover, references, rename, diagnostics, and autocompletion. Fresh is also engineered for scale — it’s built to open multi-gigabyte files with low memory overhead and keep input latency low regardless of file size, a use case that pushes past what most terminal editors are designed to handle.

A standout feature is the Orchestrator: a workspace manager that gives each task its own git worktree, runs coding agents (Claude, Codex, opencode, aider) inside them with resumable sessions, and lets a developer arrow-key between tasks while the rest keep running in the background — including over SSH to remote machines. The editor is further extensible through sandboxed TypeScript plugins running on an embedded QuickJS runtime, with a growing ecosystem covering color highlighting, TODO tracking, merge-conflict resolution, and path completion.

Fresh ships as a single statically linked binary (with an official self-update path), alongside Homebrew, winget, AUR, Debian/RPM packages, AppImage, Flatpak, npm, and crates.io distributions, and is licensed under GPL-2.0 with no paid tier or feature gating.

What You Get

• A zero-configuration editor with VS Code/Sublime-style keybindings and full mouse support out of the box
• Complete LSP integration: go-to-definition, references, hover, rename, diagnostics, and autocompletion
• Multi-cursor editing, block selection, split panes, an integrated terminal, and a file explorer
• The Orchestrator: one workspace per git worktree, each running a resumable coding-agent session (Claude, Codex, opencode, aider) you can switch between, including over SSH
• A sandboxed TypeScript plugin system (QuickJS runtime) with an existing set of community and first-party plugins
• Distribution as a single self-updating static binary, plus Homebrew, winget, AUR, .deb/.rpm, AppImage, Flatpak, npm, and crates.io packages

Common Use Cases

• A terminal-native primary editor for developers who want VS Code muscle memory without leaving the shell
• Editing and navigating very large log files or datasets that choke editors with high per-line memory overhead
• Running and supervising several AI coding agents in parallel, each isolated in its own git worktree via the Orchestrator
• Remote and SSH-based development where a full GUI editor isn’t available or practical
• Quick, dependency-free editing on servers and containers via the single static binary with no install step beyond a curl command

Under The Hood

Architecture Fresh runs a synchronous main render loop (targeting ~60fps) in src/main.rs that drains async results from a Tokio runtime (LSP, file I/O, terminal PTY, directory watching) and a dedicated plugin thread, then polls terminal input and renders. The codebase draws a clear line between Action (user intent, e.g. Save, MoveLeft) and Event (an event-sourced, undoable state change, e.g. Insert, Delete, Batch), with actions converted to events through pure functions in src/input/actions.rs and every undoable mutation centralized through Editor::apply_event_to_active_buffer, which fans out to cursor sync, layout invalidation, search-highlight updates, plugin hooks, and LSP notifications in one place. Buffer state (EditorState, in src/state.rs) is explicitly separated from per-split view state (SplitViewState, in src/view/split.rs), and a strict modal input-priority order (Settings > Menu > Prompt > Popup > normal editing) governs keyboard dispatch. This is a deliberately layered, single-writer architecture rather than a loose collection of handlers — changing the core event model would ripple through undo/redo, plugins, and LSP synchronization simultaneously.

Tech Stack Fresh is a Cargo workspace of a dozen-plus crates (fresh-editor, fresh-editor-core, fresh-core, fresh-ui, fresh-gui, fresh-languages, fresh-plugin-runtime, fresh-parser-js, fresh-winterm, fresh-input-parser, fresh-update, fresh-i18n) built on Tokio for async I/O, rquickjs for the embedded JavaScript/TypeScript plugin runtime, tree-sitter grammars for syntax highlighting and precise indentation with a syntect fallback, and crossterm for terminal control. A separate fresh-gui crate defines a windowed backend on winit/wgpu that stays fully decoupled from fresh-editor, so the terminal build never pulls in GPU dependencies. Feature flags (plugins, tree-sitter, gui, web) let a build trade functionality for a minimal static binary, and a documentation site under docs/ is built separately with VitePress.

Code Quality The project runs sixteen distinct GitHub Actions workflows covering CI, musl/FreeBSD/min-size builds, AppImage/Flatpak/AUR/winget/npm packaging, install end-to-end tests, and documentation deploys. Integration tests are consolidated into a single all_tests binary (hundreds of test modules) specifically to avoid the link-time cost of one binary per test file, and the workspace enforces custom clippy lints — for example banning direct use of tokio::runtime::Handle in favor of a project-defined LiveRuntime wrapper, with the reasoning for each ban documented inline in clippy.toml. That level of deliberate, documented lint tooling, combined with an extensive CONTRIBUTING.md describing workspace structure and build profiles, indicates an engineering culture with real conventions rather than ad hoc practices.

What Makes It Unique Fresh’s differentiator is treating terminal-editor zero-config as a first-class design constraint rather than an afterthought — most terminal editors (Vim, Emacs, Helix) trade familiarity for power and expect users to learn a new interaction model, while Fresh explicitly imports the GUI-editor interaction model wholesale into the terminal. The Orchestrator feature, which manages one git worktree and one resumable AI-agent session per task with a dock-style switcher, is a genuinely novel answer to the specific 2026-era problem of supervising multiple parallel coding agents, and its explicit support for named agent backends (Claude, Codex, opencode, aider) situates the project squarely as agent-orchestration tooling built on top of a traditional editor rather than a plain editor with agent support bolted on.

Self-Hosting

Licensing Model GPL-2.0 licensed — all features, including the LSP integration, plugin system, and the Orchestrator’s multi-agent workflows, are available in every distribution with no license key, paid tier, or feature gating.

Self-Hosting Restrictions None found — there is no cloud-hosted version of Fresh; it is a locally installed editor, and every installation method (binary, package manager, source build) ships the same feature set.