# Skink vs Neovim

> Skink vs Neovim compared honestly. Modal vs modeless editing, mouse, LSP, tree-sitter, terminal, AI agents, plugins and SSH, and who should pick which.

Source: https://skink.cc/compare/neovim/

Neovim is a modal, endlessly configurable editor with a huge plugin ecosystem. Skink is a modeless terminal editor that ships the IDE parts built in: language servers, tree-sitter, git, a terminal tab and AI agents, with Micro / VS Code style keys and full mouse support.

If you like modes and enjoy building your own setup, stay on Neovim. If you want the terminal workflow without modes or a config project, try Skink.

## Who should pick Neovim

- **Vim motions.** You think in motions and text objects (`ciw`, `dap`, `.`) and do not want to give them up.
- **Plugins.** Neovim's Lua ecosystem covers almost anything: debuggers through nvim-dap, fuzzy finders, note systems, language-specific tooling. Skink has **no plugins or scripting yet**.
- **A mature debugger.** nvim-dap has years of adapters and UI plugins behind it. Skink's built-in debugger is new.
- **Maturity.** Neovim has been in daily use by a large community for over a decade. Skink is **alpha**.

## Who should pick Skink

- **No modes.** You want to work in the terminal, over SSH, keyboard-driven, without switching between Normal and Insert mode.
- **A GUI-like mouse.** Click to place the cursor, drag to select, Alt+click for more cursors, click tabs, drag split dividers, scroll sideways with Shift+wheel or a trackpad swipe.
- **IDE features on first start.** LSP, completion, rename, code actions, git hunks and blame, project search and an AI agent panel, without assembling them from plugins.
- **One binary.** One small static binary you can drop on any server.

## Feature comparison

| | Skink | Neovim |
|---|---|---|
| Editing model | Modeless (Micro / VS Code keys) | Modal (Vim) |
| Mouse | On, always; click, drag, multi-cursor, tabs, dividers | On by default since 0.8 (`mouse=nvi`) |
| LSP | Built in, servers start on first use | Built-in client; servers configured by you (or a plugin) |
| tree-sitter | Built in, 19 languages compiled in | Built in; parsers installed per language |
| Built-in terminal | Yes, as tabs and a bottom dock | Yes, `:terminal` |
| AI agents | ACP client, agent panel, prompt box with inline diff review | Through plugins |
| Plugins | None yet | Large Lua and Vimscript ecosystem |
| Debugger (DAP) | Built in | nvim-dap plugin |
| Works over plain SSH | Yes | Yes |
| Footprint | Small (one static binary) | Small core; grows with plugins |
| Maturity | Alpha | Mature |

## What you give up, honestly

Neovim's strength is that it becomes exactly your editor. Every key, every panel and every workflow can be changed with Lua.

Skink's keys and settings are configurable in JSON, but you cannot add new behaviour yet. If you rely on a specific plugin (a test runner UI, a REPL bridge, org-mode style notes), check that Skink covers it before switching.

Skink also has no Vim emulation and no plan for one. If you want modal editing with built-in IDE features, look at [Helix](https://skink.cc/compare/helix/).

## What you get without configuring anything

- **Language servers** for Rust, TypeScript/JavaScript, Python, Go, Dart and Zig start when you open a file of that language, if the server is installed. You get completion, hover (Alt+K), go to definition (Alt+G), references (Alt+R), code actions (Alt+Enter) and rename across files through a preview with checkboxes.
- **Git**: gutter marks, stage or revert a hunk, inline blame, a git panel (Alt+Shift+C or `:gitpanel`), side-by-side diff and clickable merge-conflict resolution.
- **Terminal tabs**: F12 flips between your file and a shell, Shift+F12 opens another. They are real terminal emulators, so `htop`, `lazygit` or `claude` run unchanged.
- **AI agents** over the Agent Client Protocol: Claude Code, Gemini CLI, opencode, Goose, Codex and others. See [AI agents](https://skink.cc/tools/ai-agents/).

## Neovim keys and their Skink equivalents

The keys follow Micro, which follows common desktop editors. The ones you will reach for first:

| You did in Neovim | In Skink |
|---|---|
| `:w` | Ctrl+S (or `:w`) |
| `:q` | Ctrl+Q (or `:q`) |
| `u` / `Ctrl-r` | Ctrl+Z / Ctrl+Y |
| `/pattern`, `n` / `N` | Ctrl+F, then Ctrl+N / Ctrl+P for next / previous match |
| `v`, `V` | Shift+arrows, or drag with the mouse |
| `gd` | Alt+G (or `:def`) |
| `K` | Alt+K |
| `Ctrl-o` (jump back) | Alt+U (or `:back`) |
| Telescope find files | Alt+P (or `:recent`) |
| live grep | Alt+S or Ctrl+Shift+F (or `:grep`) |
| `:vsplit` / `:split` | Ctrl+\\ / Alt+\\ (or `:vsplit` / `:split`) |
| `q` / `@` macros | Ctrl+U records, Ctrl+J replays |
| `:terminal` | Shift+F12 or `:term` |

### Vim names in the command line

Press Ctrl+E for the command line; it shows the colon for you, so you type just `w` or `q`. Many commands keep their Vim names: `:w`, `:q`, `:e FILE`, `:vs`, `:sp`, `:only`, `:goto`.

Every key also has a typed command, such as `:comment` or `:dotfiles`. See [typed commands](https://skink.cc/editing/typed-commands/) and the full list in [shortcuts](https://skink.cc/reference/shortcuts/).

### Add your own bindings

If you miss a binding, add it to `~/.config/skink/bindings.json`:

```json
{
  "Alt-w": "Save",
  "Ctrl-5": "JumpToMatchingBrace"
}
```

**macOS:**
Many Skink shortcuts use Alt. Set your terminal to send Option as Alt, or let Skink translate Option characters (the default `"macoptionisalt": "auto"`). Any key you cannot press also runs as a typed command after Ctrl+E. See [macOS Option key](https://skink.cc/customize/macos-option-key/).

## Try it

```sh
curl -fsSL https://skink.cc/install.sh | sh
skink .
```

It installs to `~/.local/bin` without sudo, and you can keep Neovim installed side by side.

Next: [quick start](https://skink.cc/start/quick-start/), or read [a Neovim-style editor without modes](https://skink.cc/articles/modeless-editor-for-vim-users/).