Peovim

A fast, modern, cross-platform modal text editor written in Python — heavily inspired by Neovim with a clean plugin API designed for extensibility.

I've been a Vim/Neovim editor Nerd for a long time and this project grew out of the question:

• "Can a basic Vim/Neovim style modal editor be created entirely with Python?"

Achieving basic functionality was surprisingly straightforward, but then I immediately had these follow up questions:

• Can I start adding all the plugins/features that I use in Neovim?
• How slow will this be with this built using Python?

It turns out that most of the things that I wanted were relatively simple to add, especially with AI assistance. Additional features should be easy to add via the plugin API.

An optional Cython based renderer was added as a performance improvement.

Being written entirely in Python this editor is very easy to modify or create plugins for (especially with AI tools). If you are a modal editor nerd, fork this project and create your own hyper customized modal editor!.

Features

• Modal editing — Normal, Insert, Visual, and Visual Block modes with Vim-compatible bindings
• LSP support — go to definition, hover, references, rename, code actions, completions, diagnostics, inlay hints
• Syntax highlighting — tree-sitter powered, covering Python, JS/TS, Rust, Go, C/C++, Lua, and more
• Side/Bottom Panels — file explorer, document outline, diagnostics, references, workspace symbols, git status
• Git integration — status panel with staging/unstaging/discarding, branch management, diff view, log browser
• Fuzzy finder — file picker, buffer picker, live grep, command palette
• Session management — autosave/restore with per-project state
• Flash jump — 2-char jump labels (s in normal mode)
• Which-key — similar to Folke's key hint overlay Neovim plugin (my personal favorite Neovim plugin!)
• Marker groups — persistent bookmarks with annotations and gutter signs
• Local history — per-file timestamped save history
• Copilot — support for Copilot autocompletions.
• Plugin API — plain Python plugins with event hooks, keymaps, commands, decorations, and sidebar panels

Features more unique to my (Verilog, Python) workflow

• Verilog LSP — a custom LSP that allows heirarchy collapse/extract, signal tracing, and more features using veriforge

Requirements

• Python 3.13+
• uv package manager

Installation

From source (development)

git clone https://github.com/chiplukes/peovim
cd peovim
uv sync
uvx pre-commit install   # activates lint/format hooks on every commit

As a global tool

uv tool install .

After install, the peovim command is available on your PATH:

peovim              # open empty buffer
peovim file.py      # open a file

Updating

Pull the latest changes, then reinstall:

git pull
uv tool install --reinstall .

Running (development)

uv run peovim           # open empty buffer
uv run peovim file.py   # open a file

Configuration

Create init.py at the platform config path:

The config file is plain Python. Example:

# init.py

plugins.load("peovim.plugins.lsp")
plugins.load("peovim.plugins.picker")
plugins.load("peovim.plugins.explorer")
plugins.load("peovim.plugins.outline")
plugins.load("peovim.plugins.gitsigns")
plugins.load("peovim.plugins.diagnostics_panel")
plugins.load("peovim.plugins.formatter")
plugins.load("peovim.plugins.local_history")

# Space as leader (default is backslash)
options.set("leader", " ")
options.set("number", True)
options.set("relativenumber", True)
options.set("tabstop", 4)

# Custom keybindings
keymap.nmap("<leader>w", ":w<CR>", desc="Save file")

Project-local config at .peovim/init.py is also supported — the editor prompts for trust on first encounter.

A more thorough init.py can be found here:

My Init.py

Key Bindings

Navigation

LSP

Sidebar

Git Panel (when focused)

Editing

See notes/keys.md for the full key binding reference.

Ex Commands

Press <Tab> in the command line to fuzzy-browse all available commands.

Themes

Built-in themes: catppuccin (default), gruvbox, onedark.

Switch with :colorscheme <name> or set in init.py:

options.set("colorscheme", "gruvbox")

Development

# Install dev dependencies
uv sync --extra dev

# Run tests
uv run pytest tests/ --tb=no -q

# Lint / format
uv run ruff check peovim/
uv run ruff format peovim/

Optional: native Cython renderer

A Cython-accelerated renderer is included for a ~4–25× speedup on the render path. It builds automatically if a C compiler is present (cl.exe on Windows, gcc/clang on Linux/macOS). The pure-Python fallback is used otherwise — the editor runs fine either way.

# Verify which renderer is active
uv run python -c "from peovim._native import HAS_NATIVE; print(HAS_NATIVE)"

Documentation

• notes/getting_started.md — install, configuration, and getting started
• notes/keys.md — complete key binding reference
• notes/user_guide.md — day-to-day usage guide
• notes/architecture.md — internals and architecture
• notes/developer_guide.md — plugin API and contribution guide

Acknowledgments

I have spent an embarassing amount of time over the years "Configuring" Vim (and then Neovim). The plugin and editor developers are truly amazing and I strongly suggest spending time in that community to see all the creative and amazing things that are possible!

The following list was inspiration for this project:

• Neovim:
• flash.nvim — flash jump
• snacks.nvim — dashboard, notifications, indent guides
• gitsigns.nvim — git gutter and status
• mini.nvim — picker, surround, commentary
• blink.cmp — LSP completion
• conform.nvim — formatting
• which-key.nvim — key hint overlay
• todo-comments.nvim — TODO highlights
• persistence.nvim — session management
• nvim-lspconfig — LSP server configuration