# Fresh Editor: a terminal IDE that installs without configuration

> Fresh is a Rust terminal editor that ships VS Code style keybindings, LSP support and git worktree multitasking in one binary. Here is how the install paths differ, what the plugin sandbox costs you, and when a modal editor is still the better choice.

**sinelaw/fresh** — Terminal based IDE & text editor: easy, powerful and fast

- Repository: https://github.com/sinelaw/fresh
- Website: https://getfresh.dev/
- Stars: 9,050 · Forks: 343
- Language: Rust
- License: GPL-3.0
- Published: 2026-09-21 · Updated: 2026-09-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/sinelaw-fresh

## The gap Fresh targets: GUI-editor habits inside a terminal

Most terminal editors ask you to accept a trade. Modal editors give you speed and a small footprint but require you to internalize a key grammar before you are productive. Terminal editors that imitate graphical ones tend to stop at text entry: no file explorer, no diagnostics panel, no language server. Fresh positions itself against both, claiming "zero configuration" and "no modes, no memorizing shortcuts" in its README, with keybindings modeled on VS Code and Sublime Text.

The audience is therefore narrow but real: developers who already live in a terminal multiplexer, remote shell or container, and who want go-to-definition, hover and rename without opening a separate GUI editor or a full IDE over a remote connection. The feature table in the README lists LSP operations (go to definition, references, hover, code actions, rename, diagnostics, autocompletion), split panes, a file explorer, an integrated terminal and a markdown preview. That is a graphical editor's feature set, delivered as a TUI.

The second audience is less obvious. The Orchestrator gives each task its own git worktree and its own terminal, and the README lists coding agents (claude, codex, opencode, aider) with resumable sessions among the things you can run per workspace. That turns the editor into a control surface for parallel agent runs rather than a place to type. Whether that workflow appeals to you will decide more about your experience than any editing feature.

## How Fresh is put together: Rust crates, QuickJS plugins, a self-swapping binary

The workspace in Cargo.toml splits the project into thirteen crates, and the names are informative. fresh-editor is the binary; fresh-editor-core, fresh-ui and fresh-core hold the editing model and rendering; fresh-winterm and fresh-input-parser handle terminal emulation and key decoding; fresh-update implements the self-update path; fresh-i18n backs the locales/ directory; fresh-languages and fresh-parser-js cover syntax and JavaScript parsing; fresh-plugin-runtime and fresh-plugin-api-macros support the plugin system.

Plugins are TypeScript, and the README states they run sandboxed under QuickJS. That is a deliberate constraint: a TypeScript plugin cannot reach arbitrary native code, which limits what an extension can do compared with an editor that loads dynamic libraries. The README lists what ships in the box as plugins: color highlighter, TODO highlighter, merge conflicts, path complete and keymaps. Keymaps as a plugin is the interesting one, because it means the familiar keybindings are not hardcoded.

The update mechanism is the most opinionated design decision. On the universal Linux build, the binary unpacks to ~/.local/share/fresh-editor and symlinks ~/.local/bin/fresh. Because nothing else owns those files, the README says this is "the one Linux install that can replace itself": fresh --cmd update downloads the next release, checks it against a published checksum and GitHub's release attestation, and swaps the binary in place. Package-manager installs give up that ability on purpose, since the package manager owns the files. Fresh records how it was installed and updates through the same mechanism, so the choice you make at install time is sticky.

## Installing Fresh on Linux, macOS or Windows and opening a first file

The README's quick install is a shell script piped to sh. On Linux it selects the universal build: a statically linked musl binary for x86_64 and aarch64 with every feature compiled in, including plugins. It needs no root and unpacks under ~/.local.

```bash
curl -fsSL https://raw.githubusercontent.com/sinelaw/fresh/refs/heads/master/scripts/install.sh | sh
```

After it finishes, the binary lives at ~/.local/share/fresh-editor with a symlink at ~/.local/bin/fresh, so confirm that directory is on your PATH before trying to run fresh. The README also notes that the installer writes desktop entry and icon files into $XDG_DATA_HOME (usually ~/.local/share) so the editor appears in your application menu. On a server or in a container you almost certainly want to skip that:

```bash
curl -fsSL https://raw.githubusercontent.com/sinelaw/fresh/refs/heads/master/scripts/install.sh | sh -s -- --no-desktop-integration
```

The same flag is available as the environment variable FRESH_NO_DESKTOP=1. If you would rather have your distribution own the install, the installer accepts an explicit method. The README lists deb, rpm, aur, nix, cargo, npm, brew and appimage.

```bash
curl -fsSL https://raw.githubusercontent.com/sinelaw/fresh/refs/heads/master/scripts/install.sh | sh -s -- --method=deb
```

That path needs root and hands update responsibility to the package manager. --method=auto restores the older autodetecting behavior, and install.sh --help lists every option. On macOS the README points to Homebrew, and on Windows to winget; the platform table also names AUR, Terra for Fedora, FreeBSD ports, Gentoo GURU, AppImage, Flatpak, pre-built binaries, npm, cargo-binstall, crates.io, Nix flakes and building from source.

Once installed, launch it on a directory and try the two features the README leads with. Open the command palette to find files and run commands, and select a word and use multi-cursor editing to change several occurrences at once. If you have a language server configured for the file type, go to definition and hover should respond through the LSP integration. Two environment variables control the install location if the defaults do not suit you: FRESH_INSTALL_DIR and FRESH_BIN_DIR.

## What the universal build gives up, and where Fresh is the wrong tool

The self-updating universal build is convenient, but the README is explicit that only the binary is swapped on update. The desktop entry and icons are refreshed by re-running the installer, not by fresh --cmd update. If you install once and update for a year, your application-menu entry can drift from the binary that is actually running. That is a small inconsistency, but it is the kind of thing that produces confusing bug reports.

The bigger limitation is the plugin sandbox. QuickJS is a JavaScript engine, not a native extension host. Anything that needs to spawn a process, bind a socket or link a C library has to go through whatever API fresh-plugin-api-macros exposes, and the README does not describe that API's surface or its stability guarantees. Version 0.5.1 is an early number. If your workflow depends on a specific plugin, treat the plugin API as something that can move between releases rather than a contract.

Fresh is also the wrong tool if you want modal editing. The README frames the absence of modes as the selling point, and the keymaps ship as a plugin, so a Vim-like layer is not the default experience. If your muscle memory is modal and you have no interest in relearning it, an editor built around modes will cost you less. Likewise, if your environment forbids piped shell installers or requires that every binary be traceable to a distribution package, the universal build is not for you, and you should go straight to --method=deb, --method=rpm or your distro's own package. Finally, the README does not document rollback. If fresh --cmd update pulls a release that misbehaves, the documented path is forward, not back, so pinning matters more than it would with a package manager that keeps old versions around.

## Fresh against Helix and Neovim: configuration model versus editing model

The honest comparison for Fresh is with Helix and Neovim, and the difference is where each puts the burden.

Helix is a modal editor written in Rust. It ships sensible defaults, including built-in LSP support and tree-sitter grammars, and it is often described as working well without configuration. But it is modal: selection first, then action. Fresh keeps the same Rust-and-LSP foundation and rejects the modal model in favor of VS Code style keybindings, a menu bar and a command palette. If you have tried Helix and bounced off the key grammar, that is precisely the gap Fresh claims to fill.

Neovim takes the opposite approach to configuration. It is a small core with a Lua extension surface, and its ecosystem assumes you will assemble an environment from plugins. Fresh bundles the environment: file explorer, split panes, integrated terminal, diagnostics panel, theme picker and a settings UI. The cost is that Fresh's extension point is a sandboxed TypeScript runtime rather than Lua with access to the host process, so the ceiling on what a plugin can do is lower. The benefit is that a Fresh install is one binary and no init file.

There is a third axis where Fresh is unusual: the Orchestrator. Neovim and Helix are editors you configure; Fresh also wants to be the place where you run several coding agents in parallel git worktrees and switch between them. That is a different product category from a text editor, and it is the feature most likely to decide adoption for teams already running agents in bulk.

## Licence, release cadence and what an upgrade actually costs

Fresh is GPL-3.0-or-later, stated in both the repository metadata and the workspace package section of Cargo.toml. For individual use that is unremarkable. If you plan to embed Fresh in a product, link against its crates, or ship a modified binary, the copyleft terms apply, and the crates are published to crates.io under the workspace version. This is a description of the licence, not legal advice; talk to someone qualified before building on it commercially.

The release history is dense. v0.5.0 and v0.5.1 landed one day apart in September 2026, and v0.4.10 came about three weeks before that. The repository's last push was on 2026-09-21, and it is not archived. That cadence cuts both ways. Fixes arrive quickly, and so do behavior changes, which is why the update mechanism deserves attention before you rely on it.

Upgrade cost depends entirely on which install you chose. With the universal build, fresh --cmd update fetches, verifies against a checksum and a GitHub release attestation, and swaps the binary. If you set FRESH_INSTALL_DIR or FRESH_BIN_DIR, the updater follows those. With a package manager method, updates arrive when that manager decides, and Fresh defers to it. The one thing the README does not offer is a downgrade path, so on a shared machine consider whether you want the self-updating build at all or would rather let a package manager hold the version steady.

## Conclusion

Adopt Fresh if you want LSP diagnostics, multi-cursor editing and a command palette inside a terminal without writing a config file first, and if you are comfortable with a GPL-3.0 binary that replaces itself on update. Do not adopt it if you need a modal editing model, a stable plugin ABI, or a distro package that owns the update path. Before installing, read the installer's --help output and confirm whether ~/.local/bin is on your PATH.

## FAQ

### How do I install Fresh on Linux without root?

Run the quick install script from the README with curl piped to sh. On Linux it selects the universal build, a statically linked musl binary that unpacks under ~/.local, needs no root, and updates itself with fresh --cmd update.

### Does Fresh support language servers like go to definition and rename?

Yes. The README's feature table lists LSP support including go to definition, references, hover, code actions, rename, diagnostics and autocompletion.

### What language are Fresh plugins written in?

TypeScript, running in a sandboxed QuickJS runtime. The README lists color highlighter, TODO highlighter, merge conflicts, path complete and keymaps among the plugins that ship with the editor.

### Can I update Fresh if I installed it with a package manager?

Updates go through the same mechanism that installed it. The README states that Fresh records how it was installed, so a .deb or .rpm install is updated by that package manager rather than by fresh --cmd update.

### What licence is Fresh released under?

GPL-3.0-or-later, per the repository metadata and the workspace package section of Cargo.toml.

## Sources

- [License: GPL-3.0](https://github.com/sinelaw/fresh/blob/master/LICENSE)
- [Project website](https://getfresh.dev/)
- [README](https://github.com/sinelaw/fresh/blob/master/README.md)
- [Releases](https://github.com/sinelaw/fresh/releases)
- [sinelaw/fresh on GitHub](https://github.com/sinelaw/fresh)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/sinelaw-fresh