Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/anthonyamaro15/nevi

Fast terminal editor inspired by Neovim and Zed, written in Rust
https://github.com/anthonyamaro15/nevi

cli editor lsp neovim rust terminal text-editor tree-sitter vim

Last synced: 28 days ago
JSON representation

Fast terminal editor inspired by Neovim and Zed, written in Rust

Awesome Lists containing this project

README 

          
# Nevi



A fast, Neovim-inspired terminal editor written in Rust.



*Your vim muscle memory, without the configuration overhead.*



![Nevi demo — fuzzy file finder with preview, vim motions, Harpoon quick-switch, live grep, and live theme switching](nevi-demo.gif)



> **Tip:** To see every keybinding available in Nevi, run `:Keymaps` (or press `fk`) — a searchable list with a description for each one.



## Why Nevi?



**The Problem:**

I love Neovim and Zed. Zed is an amazing editor - fast, modern, and beautiful. But it doesn't have all the vim keybinds I use daily, which stopped me from fully migrating to it. Neovim is powerful but can become slow with plugins. Helix uses Kakoune-style keybindings which require relearning muscle memory.



**Nevi's Goal:**

A fast, native terminal editor where your existing vim/neovim muscle memory just works. No relearning keybindings, no plugin configuration overhead, no compromise on modern features like LSP and tree-sitter.



| Editor | Vim Keybinds | Built-in Features | Notes |

|--------|--------------|-------------------|-------|

| Neovim | Full | Via plugins | Powerful but plugin-dependent |

| Zed | Partial | Yes | Fast but vim mode incomplete |

| Helix | Kakoune-style | Yes | Different keybind philosophy |

| **Nevi** | In Progress | Yes | Aiming for full vim compatibility |



> **Note:** Nevi is under active development. Most common vim keybindings are implemented, with more being added regularly. See [Keybindings](#keybindings) for current status.



## Features



> **Note:** Currently macOS only. Linux and Windows support planned.



- **Vim/neovim keybindings** - Most common keybinds implemented, more being added regularly

- **Built-in LSP** - rust-analyzer, typescript-language-server, pyright, and more

- **Tree-sitter syntax highlighting** - Fast, accurate highlighting for Rust, TypeScript, JavaScript, Python, CSS, JSON, TOML, HTML, Markdown

- **Theme selection** - Multiple built-in colorschemes with easy switching

- **Fuzzy file finder** - Telescope-style file and content search

- **Keybinding cheatsheet** - Searchable `:Keymaps` picker (`fk`) listing every binding with a description

- **GitHub Copilot integration** - AI-powered completions

- **File explorer** - Built-in tree view

- **Git signs** - Gutter indicators for added/modified/deleted lines

- **Harpoon-style quick file switching** - Pin and jump to frequently used files

- **Markdown preview** - Open a fast, terminal-native rendered reader with `:MarkdownPreview`

- **External formatter support** - Biome, Prettier, and other formatters

- **Split windows** - Vertical and horizontal splits

- **Configurable via TOML** - Simple, readable configuration



## Installation



### Homebrew



```bash

brew install anthonyamaro15/nevi/nevi

```



Or tap first:



```bash

brew tap anthonyamaro15/nevi

brew install nevi

```



### Requirements



Nevi is currently macOS-only.



Required for Homebrew install:



- Homebrew. Build dependencies such as Rust are installed by the formula when

  needed.



Required to build from source:



- Rust toolchain with `cargo`

- Git, if cloning the repository with `git clone`

- Xcode Command Line Tools if your Rust setup prompts for native build tools



Required at runtime after any install method:



- A terminal emulator



Verify an installed binary with:



```bash

nevi --version

```



Not required:



- `ripgrep`, `grep`, `fd`, `fzf`, or the `tree-sitter` CLI. Nevi's file finder,

  live grep, fuzzy matching, and syntax highlighting are built into the binary.



Optional tools unlock optional features:



| Feature | Optional tool | Install hint |

|---------|---------------|--------------|

| `:LazyGit` / `gg` | `lazygit` | `brew install lazygit` |

| Rust LSP | `rust-analyzer` | `rustup component add rust-analyzer` |

| TypeScript / JavaScript LSP | `typescript-language-server` and `typescript` | `npm install -g typescript typescript-language-server` |

| CSS / JSON / HTML LSP | `vscode-langservers-extracted` | `npm install -g vscode-langservers-extracted` |

| TOML LSP | `taplo` | `cargo install taplo-cli --locked` |

| Python LSP | `pyright` | `npm install -g pyright` |

| Markdown LSP | `marksman` | Optional and disabled by default |

| External formatters | Whatever formatter you configure | Examples: `biome`, `prettier`, `black`, `gofmt` |

| Git signs / `:GitChanges` | A Git repository | No external `git` CLI required |

| GitHub Copilot completions | GitHub account and network access | No local Copilot binary required |



If an optional tool is missing, the rest of Nevi still works. Run

`:checkhealth` or `:Health` inside Nevi to inspect config paths, LSP settings,

profiling status, and common setup issues.



### From Source



```bash

git clone https://github.com/anthonyamaro15/nevi.git

cd nevi

cargo build --release

./target/release/nevi

```



### Add to PATH (optional)



```bash

cp target/release/nevi ~/.local/bin/

# or

sudo cp target/release/nevi /usr/local/bin/

```



## Quick Start



```bash

# Open current directory

nevi .



# Open a file

nevi src/main.rs



# Open multiple files

nevi file1.rs file2.rs

```



**Basic commands:**

- `:w` - Save

- `:q` - Quit

- `:wq` - Save and quit

- `:checkhealth` / `:Health` - Open editor health report

- `:ConfigOpen` / `:config` - Open your user config file

- `:ConfigDefaults` - View the latest built-in default config template

- `:MarkdownPreview` - Open rendered Markdown reader for `.md` files (`j/k`, `Ctrl-d/u`, `g/G`, `q`)

- `ff` - Find files

- `fg` - Live grep

- `gc` - Git changes picker

- `e` - File explorer

- `tt` - Terminal picker

- `tn` / `tj` / `tk` - New / next / previous terminal session

- `tr` - Rename active terminal session

- `fk` - Search keymaps (keybinding cheatsheet)



## Configuration



Config location: `~/.config/nevi/config.toml`



A template config file is created automatically on first run. Here's an example:



```toml

[editor]

tab_width = 2

format_on_save = true

relative_numbers = true

scroll_off = 8



[theme]

colorscheme = "onedark"



[terminal]

popup_width_ratio = 0.9

popup_height_ratio = 0.9



[lsp]

enabled = true



[copilot]

enabled = true

```



Run `:ConfigOpen` (or `:config`) to open your user config file from inside

Nevi. Run `:ConfigDefaults` to view the latest built-in default config template

without changing your existing config. Existing config files stay user-owned;

Nevi does not rewrite them when new defaults are added.



See the generated config file at `~/.config/nevi/config.toml` for all available

options with documentation.



## Custom Themes



Nevi comes with 15+ built-in themes. You can also create your own custom themes.



### Built-in Themes



Select a theme with `:theme ` or `ft` to open the theme picker.



Available themes: `onedark`, `dracula`, `gruvbox`, `nord`, `tokyonight`, `catppuccin-mocha`, `rose-pine`, `solarized-dark`, `kanagawa`, `monokai`, `everforest`, `github-dark`, `ayu-dark`, `palenight`, `nightfox`



### Creating Custom Themes



1. **Location:** Place `.toml` files in `~/.config/nevi/themes/`

2. **Template:** A commented template is auto-generated at `~/.config/nevi/themes/_template.toml`

3. **Naming:** The filename becomes the theme name (e.g., `mytheme.toml` → `:theme mytheme`)



Copy the template to get started:



```bash

cp ~/.config/nevi/themes/_template.toml ~/.config/nevi/themes/mytheme.toml

```



### Theme Structure



```toml

# Define reusable colors

[palette]

red = "#e06c75"

blue = "#61afef"

bg = "#282c34"



# Syntax highlighting (can reference palette or use hex)

[syntax]

keyword = { fg = "purple" }

string = { fg = "green" }

comment = { fg = "gray", italic = true }



# UI elements

[ui]

background = "bg"

foreground = "#abb2bf"

cursor_line = "#2c313c"



[ui.statusline]

mode_normal = "blue"

mode_insert = "green"



# And more: [ui.completion], [ui.finder], [diagnostic], [git]

```



See `~/.config/nevi/themes/_template.toml` for the complete reference with all available options.



## Keybindings



Nevi aims for full vim/neovim keybind compatibility. Most common keybindings are already implemented.



> **Full reference:** See [KEYBINDINGS.md](KEYBINDINGS.md) for the complete keybind documentation with examples and tips.



### Movement

`h/j/k/l`, `w/b/e/W/B/E`, `0/^/$`, `+/-`, `gg/G`, `{/}`, `(`/`)`, `f/F/t/T`, `;/,`, `%`, `H/M/L`, `gj/gk/g0/g$/g^`



### Editing

`d/c/y` + motions, `dd/cc/yy`, `p/P/gp/gP`, `x/X`, `r`, `J/gJ`, `==/={motion}`, `.`, `u/Ctrl+r`



### Text Objects

`iw/aw`, `iW/aW`, `i"/a"`, `i'/a'`, `i(/a(`, `i{/a{`, `i[/a[`, `i`)

Press `` by itself to show available leader continuations. Set `[keymap] show_leader_popup = false` to disable that popup.



| Key | Action |

|-----|--------|

| `ff` | Find files |

| `fg` | Live grep |

| `sw` | Search word under cursor |

| `fb` | Find buffers |

| `ft` | Theme picker |

| `fk` | Search keymaps |

| `tt` | Terminal picker |

| `e` | File explorer |

| `ca` | Code actions |

| `rn` | Rename symbol |

| `d` | Search diagnostics |

| `D` | Line diagnostic |

| `w` | Save file |

| `q` | Quit |

| `gg` | Open lazygit |

| `gc` | Git changes picker |

| `m` | Add to harpoon |

| `h` | Harpoon menu |

| `1-4` | Jump to harpoon slot |



### Window Management

`Ctrl+w v` (vsplit), `Ctrl+w s` (hsplit), `Ctrl+w q` (close), `Ctrl+w h/j/k/l` or `Ctrl+h/j/k/l` (navigate), `Ctrl+w w/W` (next/previous), `Ctrl+w =` (equalize), `Ctrl+w r/R` (rotate), `Ctrl+w x` (exchange)



### And More

Visual mode (`v/V/Ctrl+v`), macros (`q{a-z}/@{a-z}`), marks (`m{a-z}/'`), read-only/expression registers (`"%`, `":`, `"#`, `".`, `"=`), insert helpers (`Ctrl+t/Ctrl+d/Ctrl+a/Ctrl+r/Ctrl+o`), replace mode (`R`)



> **Missing a keybind?** Check [KEYBINDINGS.md](KEYBINDINGS.md) for the full list of what's implemented. If you don't see the one you want, take a look at the [keybind roadmap](KEYBINDS_ROADMAP.md) to see if it's already planned — and if it's not, [open an issue](https://github.com/anthonyamaro15/nevi/issues) to request it (PRs welcome too).



## Language Support



### LSP Servers



| Language | Server | Status |

|----------|--------|--------|

| Rust | rust-analyzer | Supported |

| TypeScript/JavaScript | typescript-language-server | Supported |

| Python | pyright | Supported |

| CSS/SCSS | vscode-css-language-server | Supported |

| JSON | vscode-json-language-server | Supported |

| TOML | taplo | Supported |

| HTML | vscode-html-language-server | Supported |

| Markdown | marksman | Optional, disabled by default |



LSP servers are auto-detected when installed. See [`~/.config/nevi/config.toml`](#configuration) for LSP configuration options.



If a server is missing, Nevi shows an install hint in the LSP status/error

message. You can also run `:checkhealth` to review the active LSP configuration.



> **Missing a language?** Open a [GitHub issue](https://github.com/anthonyamaro15/nevi/issues) and we'll work on adding support!



### External Formatters



Configure formatters in `~/.config/nevi/languages.toml`:



```toml

[typescript]

formatter = { command = "biome", args = ["format", "--stdin-file-path", "{file}"] }

```



Formatters are external commands. Nevi only runs a formatter if you configure

one; otherwise it falls back to LSP formatting when available.



## Contributing



Contributions are welcome! Please feel free to submit issues and pull requests.



- [Report a bug](https://github.com/anthonyamaro15/nevi/issues)

- [Request a feature](https://github.com/anthonyamaro15/nevi/issues)



### Performance Profiling



Profiling is opt-in and disabled by default. To capture hot-path timings while

using Nevi locally:



```bash

NEVI_PROFILE=1 cargo run --release -- path/to/file

```



Nevi writes raw timing events and a summary to `/tmp/nevi_profile.log`. The

summary includes count, retained sample count, total, average, p50, p95, and max

microseconds for metrics such as key handling, syntax updates, full renders, and

terminal-only renders.



Run `:checkhealth` (or `:Health`) inside Nevi to see config paths, config

discoverability commands, LSP settings, profiling status, and any profile

summary from `/tmp/nevi_profile.log`. Profile summaries are written when a

profiled Nevi session exits.



## License



MIT License



## Acknowledgments



Inspired by [Neovim](https://neovim.io/), [Helix](https://helix-editor.com/), and [Zed](https://zed.dev/).



Built with:

- [ropey](https://github.com/cessen/ropey) - Rope data structure for text

- [tree-sitter](https://tree-sitter.github.io/tree-sitter/) - Syntax highlighting

- [crossterm](https://github.com/crossterm-rs/crossterm) - Terminal handling

- [nucleo](https://github.com/helix-editor/nucleo) - Fuzzy matching

- [git2](https://github.com/rust-lang/git2-rs) - Git integration