[opensourcedex]

fresh is a free, open source ides & code editors project written in Rust and released under GPL-3.0. It has 8,996 GitHub stars, 342 forks and 369 open issues, and was last pushed 2 hours ago. On this registry it ranks #15 of 22 tracked projects in IDEs & Code Editors, with 5 head-to-head comparisons available.

What is fresh?

Fresh is a terminal-based IDE and text editor written in Rust and released under the GPL-3.0 licence, aimed at developers who want the familiar editing experience of a graphical editor inside a terminal, with zero configuration required.

What it is

Fresh is a full-featured terminal text editor and IDE, categorised in this registry under Developer Tools / IDEs & Code Editors and tagged ide, terminal-based, and text-editor. It is developed in the open on GitHub, where it has 8,996 stars, 342 forks, and 369 open issues, with documentation and downloads hosted at getfresh.dev. The design premise is zero configuration: familiar keybindings, full mouse support, menus, and a command palette, with no modes and no shortcut memorisation. The project is written in Rust and distributed under the GPL-3.0 licence.

The problem it addresses is the split between terminal workflows and graphical editing. Fresh brings the intuitive user experience of VS Code and Sublime Text to the terminal, so the editing model those editors popularised — standard keybindings, menus, a command palette, multi-cursor editing — is available without leaving the shell. It is also engineered for workloads that commonly strain editors: Fresh handles multi-gigabyte files with negligible memory overhead and delivers consistently low-latency input regardless of file size. The Orchestrator extends this into multitasking, giving each task its own git worktree workspace with terminals, long-running commands, and coding agents.

Key capabilities

  • A command palette and fuzzy finder that locate files, run commands, switch buffers, and jump to any line from a single shortcut.
  • Language Server (LSP) support covering go to definition, references, hover, code actions, rename, diagnostics, and autocompletion.
  • Editing facilities including multi-cursor editing, block selection, undo/redo, smart indent, comment toggling, and clipboard operations.
  • Search and replace through incremental search, find in selection, query replace, and git grep, plus navigation by line, bracket, bookmarks, position history, and diagnostics.
  • The Orchestrator, which assigns one workspace per git worktree, runs terminals and long-running commands per workspace, hosts coding agents (claude, codex, opencode, aider) with resumable sessions, and provides a dock switcher and remote/SSH workspaces.
  • Extensibility through TypeScript plugins running sandboxed in QuickJS, alongside a color highlighter, TODO highlighter, merge conflict handling, path completion, and keymaps.
  • Themes and customization via instant theme browsing, a full settings UI, and an interactive keybinding editor.

Who uses it and how

  • Developers working over SSH or in remote/SSH workspaces who need IDE-level navigation, diagnostics, and completion without a graphical editor on the remote host.
  • Engineers running several tasks in parallel: the Orchestrator places each task in its own git worktree, with per-workspace terminals and long-running commands, switched with an arrow key.
  • Users who routinely open very large files, since multi-gigabyte files load with negligible memory overhead and low input latency.
  • Editors moving from VS Code or Sublime Text who want the same mental model in a terminal, including the mouse support, menus, and command palette they already expect.
  • Teams that run coding agents such as claude, codex, opencode, or aider next to their editor and rely on resumable sessions in per-workspace terminals.

Getting started

Quick install is a single command: curl -fsSL https://raw.githubusercontent.com/sinelaw/fresh/refs/heads/master/scripts/install.sh | sh. On Linux this installs the universal statically linked binary under ~/.local with no root required, and it updates itself with fresh --cmd update; on macOS the installer uses Homebrew, and distro packages are opt-in through --method=deb, rpm, aur, nix, cargo, npm, brew, or appimage.

How it compares

Fresh explicitly positions itself as bringing the intuitive UX of VS Code and Sublime Text to the terminal, so the comparison is one of environment rather than feature set: it occupies the terminal, where those two are graphical applications. It also goes beyond plain editing by bundling the Orchestrator, LSP integration, and plugin support into one binary, which overlaps with what a graphical editor plus external tooling would otherwise provide.

When to use it — and when not to

Fresh is terminal-only, so anyone who needs a graphical editor, or the full extension ecosystem that ships with one, should not pick it. Updating depends on how it was installed: the default script keeps the binary under the user's home directory and self-updates, while package-manager installs need root and hand updates to that package manager. The facts describe a single binary with no server-side components, so there is little infrastructure to operate, but the 369 open issues and GPL-3.0 licence terms are worth reviewing before committing a team to it.

project readme (upstream, from github) — read inline

Fresh

A modern, full-featured terminal text editor, with zero configuration. Familiar keybindings, mouse support, and IDE-level features — no learning curve required.

Official Website  ·  Documentation  ·  Discord  ·  Contributing

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

Fresh Demo

Fresh brings the intuitive UX of VS Code and Sublime Text to the terminal. Standard keybindings, full mouse support, menus, and a command palette — everything works the way you'd expect, right out of the box. No modes, no memorizing shortcuts.

Built for real-world performance: Fresh handles multi-gigabyte files with negligible memory overhead and delivers consistently low-latency input, regardless of file size.

Command Palette & Fuzzy Finder

One shortcut to find files, run commands, switch buffers, and jump to any line.

Command Palette

Multitask with the Orchestrator

Start each task in its own worktree, hop between them with an arrow key, and leave the rest running.

Orchestrator

Multi-Cursor Editing

Select and edit multiple occurrences simultaneously — the same workflow you know from graphical editors.

Multi-Cursor

Themes & Customization

Browse and apply color themes instantly. Full settings UI and interactive keybinding editor included.

Select Theme

See more feature demos: Editing (search & replace, block selection, sort lines, ...) · Productivity (file explorer, split view, integrated terminal, ...) · Themes

Feature Overview

Category Features
File Management open/save/new/close, file explorer, tabs, auto-revert, git file finder
Editing undo/redo, multi-cursor, block selection, smart indent, comments, clipboard
Search & Replace incremental search, find in selection, query replace, git grep
Navigation go to line/bracket, word movement, position history, bookmarks, error navigation
Views & Layout split panes, line numbers, line wrap, backgrounds, markdown preview
Language Server (LSP) go to definition, references, hover, code actions, rename, diagnostics, autocompletion
Productivity command palette, menu bar, keyboard macros, git log, diagnostics panel
Multitasking (Orchestrator) one workspace per git worktree, terminals and long-running commands per workspace, coding agents (claude, codex, opencode, aider) with resumable sessions, dock switcher, remote/SSH workspaces
Extensibility TypeScript plugins (sandboxed QuickJS), color highlighter, TODO highlighter, merge conflicts, path complete, keymaps
Internationalization Multiple language support (see locales/), plugin translation system

Installation

Quick install:

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

On Linux this installs the universal build: one statically linked binary that runs on every distro, unpacked under ~/.local, owned by you. It needs no root, and it updates itself — fresh --cmd update, or the update prompt in the editor. On macOS it uses Homebrew.

Prefer your distro's package manager? Ask for it explicitly:

curl -fsSL .../install.sh | sh -s -- --method=deb    # also: rpm, aur, nix, cargo, npm, brew, appimage

Packages are fully supported — they are opt-in rather than the default because installing one needs root and hands updates to that package manager. fresh records how it was installed either way, and updates through that same mechanism. --method=auto restores the old autodetecting behaviour, and install.sh --help lists everything.

Or, pick your preferred method:

Platform Method
Linux (any distro) universal build — self-updating, no root
macOS brew
Bazzite/Bluefin/Aurora Linux brew
Windows winget
Arch Linux AUR
Debian/Ubuntu .deb
Fedora/RHEL .rpm, Terra
OpenSUSE .rpm
FreeBSD ports / pkg
Gentoo GURU
Linux (sandboxed / portable) AppImage, Flatpak
All platforms Pre-built binaries
npm npm / npx
Rust users (Fast) cargo-binstall
Rust users crates.io
Nix Nix flakes
Developers From source

Universal build (Linux)

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

A single static (musl) binary for x86_64 and aarch64 with every feature compiled in, including plugins. It unpacks to ~/.local/share/fresh-editor and symlinks ~/.local/bin/fresh; set FRESH_INSTALL_DIR / FRESH_BIN_DIR to put them elsewhere. Ensure ~/.local/bin is in your PATH.

Because nothing else owns these files, this is the one Linux install that can replace itself: fresh --cmd update downloads the next release, verifies it against both its published checksum and GitHub's release attestation, and swaps the binary in place.

The archive also carries the same desktop entry and icon theme the .deb and .rpm install, and the installer copies them into $XDG_DATA_HOME (~/.local/share by default) so Fresh shows up in your application menu. Pass --no-desktop-integration, or set FRESH_NO_DESKTOP=1, to skip that — usually what you want on a server or in a container. Every file written outside the install directory is listed in ~/.local/share/fresh-editor/installed-files.txt, so re-running the installer cleans up after the previous run and uninstalling is rm over that list plus the install directory and the symlink.

Downloading the archive by hand from the releases page works the same way — it ships the same install receipt, so a hand-unpacked copy self-updates too. Only the binary is swapped on update, so the desktop entry and icons are refreshed by re-running the installer, not by fresh --cmd update.

Brew

On macOS and some linux distros (Bazzite/Bluefin/Aurora):

Note: On macOS, see macOS Terminal Tips for recommended terminal configuration.

brew install fresh-editor

Windows (winget)

winget install fresh-editor

Alternatively, Windows users can use npm.

Arch Linux (AUR)

Binary package (recommended, faster install):

git clone https://aur.archlinux.org/fresh-editor-bin.git
cd fresh-editor-bin
makepkg --syncdeps --install

Build from source:

git clone https://aur.archlinux.org/fresh-editor.git
cd fresh-editor
makepkg --syncdeps --install

Using an AUR helper (such as yay or paru):

# Binary package (recommended, faster install)
yay -S fresh-editor-bin

# Or build from source
yay -S fresh-editor

Debian/Ubuntu (.deb)

Download and install the latest release:

curl -sL $(curl -s https://api.github.com/repos/sinelaw/fresh/releases/latest | grep "browser_download_url.*_$(dpkg --print-architecture)\.deb" | cut -d '"' -f 4) -o fresh-editor.deb && sudo dpkg -i fresh-editor.deb

Or download the .deb file manually from the releases page.

Fedora/RHEL (.rpm)

Download and install the latest release:

curl -sL $(curl -s https://api.github.com/repos/sinelaw/fresh/releases/latest | grep "browser_download_url.*\.$(uname -m)\.rpm" | cut -d '"' -f 4) -o fresh-editor.rpm && sudo rpm -U fresh-editor.rpm

Or download the .rpm file manually from the releases page.

OpenSUSE (.rpm)

There is no openSUSE repository for fresh yet, so install the .rpm from the release directly:

curl -sL $(curl -s https://api.github.com/repos/sinelaw/fresh/releases/latest | grep "browser_download_url.*\.$(uname -m)\.rpm" | cut -d '"' -f 4) -o fresh-editor.rpm && sudo zypper --no-gpg-checks install ./fresh-editor.rpm

Or download the .rpm file manually from the releases page.

Gentoo (GURU)

Enable the repository as read in Project:GURU/Information for End Users then emerge the package:

emerge --ask app-editors/fresh

AppImage

On most systems the universal build is the better choice: same "runs anywhere" property, no FUSE dependency, and no mount overhead on each launch. install.sh no longer selects AppImage automatically — pass --method=appimage if you specifically want it.

Download the .AppImage file from the releases page and run:

chmod +x fresh-editor-VERSION-x86_64.AppImage
./fresh-editor-VERSION-x86_64.AppImage

For faster startup (recommended): Extract the AppImage instead of running it directly. This avoids the FUSE mount overhead on each launch (~10x faster):

./fresh-editor-VERSION-x86_64.AppImage --appimage-extract
mkdir -p ~/.local/share/fresh-editor ~/.local/bin
mv squashfs-root/* ~/.local/share/fresh-editor/
ln -sf ~/.local/share/fresh-editor/usr/bin/fresh ~/.local/bin/fresh

Ensure ~/.local/bin is in your PATH. Available for x86_64 and aarch64 architectures.

Flatpak

Download the .flatpak bundle from the releases page and install:

flatpak install --user fresh-editor-VERSION-x86_64.flatpak
flatpak run io.github.sinelaw.fresh

See flatpak/README.md for building from source.

Pre-built binaries

Download the latest release for your platform from the releases page.

On Linux, prefer the -unknown-linux-musl archives: they are statically linked, so they run on any distro regardless of its glibc version, and they are gzipped so a stock tar can unpack them without xz-utils. Every archive carries an install receipt, so an unpacked copy knows how to update itself.

Using mise

mise use github:sinelaw/fresh

npm

npm install -g @fresh-editor/fresh-editor

Or try it without installing:

npx @fresh-editor/fresh-editor

Using cargo-binstall

To install the binary directly without compiling (much faster than crates.io):

First, install cargo-binstall if you haven't already

cargo install cargo-binstall

Then install fresh

cargo binstall fresh-editor

Nix flakes

Run without installing:

nix run github:sinelaw/fresh

Or install to your profile:

nix profile add github:sinelaw/fresh

From crates.io

cargo install --locked fresh-editor

From source

git clone https://github.com/sinelaw/fresh.git
cd fresh
cargo build --release
./target/release/fresh [file]

Documentation

Contributing

See CONTRIBUTING.md for guidelines.

Privacy

Fresh checks for new versions daily to notify you of available upgrades. Alongside this, it sends basic anonymous telemetry (version, OS/architecture, terminal type) to help understand usage patterns. No personal data or file contents are collected.

To disable both upgrade checks and telemetry, use --no-upgrade-check or set check_for_updates: false in your config.

License

Copyright (c) Noam Lewis

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version (GPL-3.0-or-later).

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

SPDX-License-Identifier: GPL-3.0-or-later

Frequently asked questions

Is fresh free to use?

fresh is open source under the GPL-3.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does fresh do?

Terminal based IDE & text editor: easy, powerful and fast

What is fresh written in?

fresh is primarily written in Rust. Its source is publicly available at https://github.com/sinelaw/fresh, and it has 8,996 GitHub stars.