GitHub Lua Daily Trending

olimorris/codecompanion.nvim

✨ AI Coding, Vim Style

Code with LLMs and Agents via the in-built adapters, the community adapters or by building your own

New features are always announced here

💜 Sponsors

Thank you to the following people:

If you love CodeCompanion and use it in your workflow, please consider sponsoring me

✨ Features

💬 Copilot Chat meets Zed AI, in Neovim
⚡ Integrates Neovim with LLMs and Agents in the CLI
🔌 Support for LLMs from Anthropic, Copilot, GitHub Models, DeepSeek, Gemini, Mistral AI, Novita, Ollama, OpenAI, Azure OpenAI, HuggingFace and xAI (or bring your own)
🤖 Support for Agent Client Protocol, enabling coding with agents like Augment Code, Cagent from Docker, Claude Code, Codex, Copilot CLI, Gemini CLI, Goose, Cursor CLI, Kimi CLI, Kiro, Mistral Vibe and OpenCode
🫶 User contributed and supported adapters
🔋 Support for Model Context Protocol (MCP)
🚀 Inline transformations, code creation and refactoring
🎨 Editor Context, Slash Commands, Agents/Tools and Workflows to improve LLM output
🧠 Support for rules files like CLAUDE.md, .cursor/rules and your own custom ones
✨ Built-in prompt library for common tasks like advice on LSP errors and code explanations
🏗️ Create your own custom prompts, Editor Context and Slash Commands
📚 Have multiple chats open at the same time
🎨 Support for vision and images as input
💪 Async execution for fast performance

📸 In Action

🚀 Getting Started

Everything you need to know about CodeCompanion (installation, configuration and usage) is within the docs.

🧰 Troubleshooting

Before raising an issue, there are a number of steps you can take to troubleshoot a problem:

Checkhealth

Run :checkhealth codecompanion and check all dependencies are installed correctly. Also take note of the log file path.

Turn on logging

Update your config and turn debug logging on:

-- lazy.nvim
{
  "olimorris/codecompanion.nvim",
  dependencies = {
    "nvim-lua/plenary.nvim",
    "nvim-treesitter/nvim-treesitter",
  },
  opts = {
    -- NOTE: The log_level is in `opts.opts`
    opts = {
      log_level = "DEBUG", -- or "TRACE"
    },
  },
},

-- Other package managers
require("codecompanion").setup({
  opts = {
    log_level = "DEBUG", -- or "TRACE"
  }
})

and inspect the log file as per the location from the checkhealth command.

Try with a minimal.lua file

A large proportion of issues which are raised in Neovim plugins are to do with a user's own config. That's why I always ask users to fill in a minimal.lua file when they raise an issue. We can rule out their config being an issue and it allows me to recreate the problem.

For this purpose, I have included a minimal.lua file in the repository for you to test out if you're facing issues. Simply copy the file, edit it and run neovim with nvim --clean -u minimal.lua.

🎁 Contributing

I am open to contributions but they will be implemented at my discretion. Feel free to open up a discussion before embarking on a PR and please read the CONTRIBUTING.md guide.

👏 Acknowledgements

Steven Arcangeli for his genius creation of the chat buffer and his feedback early on
Wtf.nvim for the LSP assistant action
CopilotChat.nvim for the rendering and usability of the chat buffer
Aerial.nvim for the Tree-sitter parsing which inspired the symbols Slash Command
Saghen for the fantastic docs inspiration from blink.cmp and continued PRs to the project
Catwell for the queue inspiration that I use to stack agents and tools
bassamsdata for the amazing insert_edit_into_file tool (the list is endless) and ongoing contributions to this project
ravitemer for the fantastic extensions API
Davidyz for his continued, excellent contributions that keep CodeCompanion going
Conrad Irwin, Agus Zubiaga and Morgan Krey from Zed Industries for their support in implementing ACP
Sidekick.nvim for the diff and terminal input inspiration

folke/snacks.nvim

🍿 A collection of QoL plugins for Neovim

🍿 `snacks.nvim`

A collection of small QoL plugins for Neovim.

✨ Features

Snack	Description	Setup
animate	Efficient animations including over 45 easing functions (library)
bigfile	Deal with big files	‼️
bufdelete	Delete buffers without disrupting window layout
dashboard	Beautiful declarative dashboards	‼️
debug	Pretty inspect & backtraces for debugging
dim	Focus on the active scope by dimming the rest
explorer	A file explorer (picker in disguise)	‼️
gh	GitHub CLI integration
git	Git utilities
gitbrowse	Open the current file, branch, commit, or repo in a browser (e.g. GitHub, GitLab, Bitbucket)
image	Image viewer using Kitty Graphics Protocol, supported by `kitty`, `wezterm` and `ghostty`	‼️
indent	Indent guides and scopes
input	Better `vim.ui.input`	‼️
keymap	Better `vim.keymap` with support for filetypes and LSP clients
layout	Window layouts
lazygit	Open LazyGit in a float, auto-configure colorscheme and integration with Neovim
notifier	Pretty `vim.notify`	‼️
notify	Utility functions to work with Neovim's `vim.notify`
picker	Picker for selecting items	‼️
profiler	Neovim lua profiler
quickfile	When doing `nvim somefile.txt`, it will render the file as quickly as possible, before loading your plugins.	‼️
rename	LSP-integrated file renaming with support for plugins like neo-tree.nvim and mini.files.
scope	Scope detection, text objects and jumping based on treesitter or indent	‼️
scratch	Scratch buffers with a persistent file
scroll	Smooth scrolling	‼️
statuscolumn	Pretty status column	‼️
terminal	Create and toggle floating/split terminals
toggle	Toggle keymaps integrated with which-key icons / colors
util	Utility functions for Snacks (library)
win	Create and manage floating windows or splits
words	Auto-show LSP references and quickly navigate between them	‼️
zen	Zen mode • distraction-free coding

⚡️ Requirements

Neovim >= 0.9.4
for proper icons support:
- mini.icons (optional)
- nvim-web-devicons (optional)
- a Nerd Font (optional)

📦 Installation

Install the plugin with your package manager:

lazy.nvim

Important

A couple of plugins require snacks.nvim to be set-up early. Setup creates some autocmds and does not load any plugins. Check the code to see what it does.

Caution

You need to explicitly pass options for a plugin or set enabled = true to enable it.

Tip

It's a good idea to run :checkhealth snacks to see if everything is set up correctly.

{
  "folke/snacks.nvim",
  priority = 1000,
  lazy = false,
  ---@type snacks.Config
  opts = {
    -- your configuration comes here
    -- or leave it empty to use the default settings
    -- refer to the configuration section below
    bigfile = { enabled = true },
    dashboard = { enabled = true },
    explorer = { enabled = true },
    indent = { enabled = true },
    input = { enabled = true },
    picker = { enabled = true },
    notifier = { enabled = true },
    quickfile = { enabled = true },
    scope = { enabled = true },
    scroll = { enabled = true },
    statuscolumn = { enabled = true },
    words = { enabled = true },
  },
}

For an in-depth setup of snacks.nvim with lazy.nvim, check the example below.

⚙️ Configuration

Please refer to the readme of each plugin for their specific configuration.

Default Options

---@class snacks.Config
---@field animate? snacks.animate.Config
---@field bigfile? snacks.bigfile.Config
---@field dashboard? snacks.dashboard.Config
---@field dim? snacks.dim.Config
---@field explorer? snacks.explorer.Config
---@field gh? snacks.gh.Config
---@field gitbrowse? snacks.gitbrowse.Config
---@field image? snacks.image.Config
---@field indent? snacks.indent.Config
---@field input? snacks.input.Config
---@field layout? snacks.layout.Config
---@field lazygit? snacks.lazygit.Config
---@field notifier? snacks.notifier.Config
---@field picker? snacks.picker.Config
---@field profiler? snacks.profiler.Config
---@field quickfile? snacks.quickfile.Config
---@field scope? snacks.scope.Config
---@field scratch? snacks.scratch.Config
---@field scroll? snacks.scroll.Config
---@field statuscolumn? snacks.statuscolumn.Config
---@field terminal? snacks.terminal.Config
---@field toggle? snacks.toggle.Config
---@field win? snacks.win.Config
---@field words? snacks.words.Config
---@field zen? snacks.zen.Config
---@field styles? table<string, snacks.win.Config>
---@field image? snacks.image.Config|{}
{
  image = {
    -- define these here, so that we don't need to load the image module
    formats = {
      "png",
      "jpg",
      "jpeg",
      "gif",
      "bmp",
      "webp",
      "tiff",
      "heic",
      "avif",
      "mp4",
      "mov",
      "avi",
      "mkv",
      "webm",
      "pdf",
      "icns",
    },
  },
}

Some plugins have examples in their documentation. You can include them in your config like this:

{
  dashboard = { example = "github" }
}

If you want to customize options for a plugin after they have been resolved, you can use the config function:

{
  gitbrowse = {
    config = function(opts, defaults)
      table.insert(opts.remote_patterns, { "my", "custom pattern" })
    end
  },
}

🚀 Usage

See the example below for how to configure snacks.nvim.

{
  "folke/snacks.nvim",
  priority = 1000,
  lazy = false,
  ---@type snacks.Config
  opts = {
    bigfile = { enabled = true },
    dashboard = { enabled = true },
    explorer = { enabled = true },
    indent = { enabled = true },
    input = { enabled = true },
    notifier = {
      enabled = true,
      timeout = 3000,
    },
    picker = { enabled = true },
    quickfile = { enabled = true },
    scope = { enabled = true },
    scroll = { enabled = true },
    statuscolumn = { enabled = true },
    words = { enabled = true },
    styles = {
      notification = {
        -- wo = { wrap = true } -- Wrap notifications
      }
    }
  },
  keys = {
    -- Top Pickers & Explorer
    { "<leader><space>", function() Snacks.picker.smart() end, desc = "Smart Find Files" },
    { "<leader>,", function() Snacks.picker.buffers() end, desc = "Buffers" },
    { "<leader>/", function() Snacks.picker.grep() end, desc = "Grep" },
    { "<leader>:", function() Snacks.picker.command_history() end, desc = "Command History" },
    { "<leader>n", function() Snacks.picker.notifications() end, desc = "Notification History" },
    { "<leader>e", function() Snacks.explorer() end, desc = "File Explorer" },
    -- find
    { "<leader>fb", function() Snacks.picker.buffers() end, desc = "Buffers" },
    { "<leader>fc", function() Snacks.picker.files({ cwd = vim.fn.stdpath("config") }) end, desc = "Find Config File" },
    { "<leader>ff", function() Snacks.picker.files() end, desc = "Find Files" },
    { "<leader>fg", function() Snacks.picker.git_files() end, desc = "Find Git Files" },
    { "<leader>fp", function() Snacks.picker.projects() end, desc = "Projects" },
    { "<leader>fr", function() Snacks.picker.recent() end, desc = "Recent" },
    -- git
    { "<leader>gb", function() Snacks.picker.git_branches() end, desc = "Git Branches" },
    { "<leader>gl", function() Snacks.picker.git_log() end, desc = "Git Log" },
    { "<leader>gL", function() Snacks.picker.git_log_line() end, desc = "Git Log Line" },
    { "<leader>gs", function() Snacks.picker.git_status() end, desc = "Git Status" },
    { "<leader>gS", function() Snacks.picker.git_stash() end, desc = "Git Stash" },
    { "<leader>gd", function() Snacks.picker.git_diff() end, desc = "Git Diff (Hunks)" },
    { "<leader>gf", function() Snacks.picker.git_log_file() end, desc = "Git Log File" },
    -- gh
    { "<leader>gi", function() Snacks.picker.gh_issue() end, desc = "GitHub Issues (open)" },
    { "<leader>gI", function() Snacks.picker.gh_issue({ state = "all" }) end, desc = "GitHub Issues (all)" },
    { "<leader>gp", function() Snacks.picker.gh_pr() end, desc = "GitHub Pull Requests (open)" },
    { "<leader>gP", function() Snacks.picker.gh_pr({ state = "all" }) end, desc = "GitHub Pull Requests (all)" },
    -- Grep
    { "<leader>sb", function() Snacks.picker.lines() end, desc = "Buffer Lines" },
    { "<leader>sB", function() Snacks.picker.grep_buffers() end, desc = "Grep Open Buffers" },
    { "<leader>sg", function() Snacks.picker.grep() end, desc = "Grep" },
    { "<leader>sw", function() Snacks.picker.grep_word() end, desc = "Visual selection or word", mode = { "n", "x" } },
    -- search
    { '<leader>s"', function() Snacks.picker.registers() end, desc = "Registers" },
    { '<leader>s/', function() Snacks.picker.search_history() end, desc = "Search History" },
    { "<leader>sa", function() Snacks.picker.autocmds() end, desc = "Autocmds" },
    { "<leader>sb", function() Snacks.picker.lines() end, desc = "Buffer Lines" },
    { "<leader>sc", function() Snacks.picker.command_history() end, desc = "Command History" },
    { "<leader>sC", function() Snacks.picker.commands() end, desc = "Commands" },
    { "<leader>sd", function() Snacks.picker.diagnostics() end, desc = "Diagnostics" },
    { "<leader>sD", function() Snacks.picker.diagnostics_buffer() end, desc = "Buffer Diagnostics" },
    { "<leader>sh", function() Snacks.picker.help() end, desc = "Help Pages" },
    { "<leader>sH", function() Snacks.picker.highlights() end, desc = "Highlights" },
    { "<leader>si", function() Snacks.picker.icons() end, desc = "Icons" },
    { "<leader>sj", function() Snacks.picker.jumps() end, desc = "Jumps" },
    { "<leader>sk", function() Snacks.picker.keymaps() end, desc = "Keymaps" },
    { "<leader>sl", function() Snacks.picker.loclist() end, desc = "Location List" },
    { "<leader>sm", function() Snacks.picker.marks() end, desc = "Marks" },
    { "<leader>sM", function() Snacks.picker.man() end, desc = "Man Pages" },
    { "<leader>sp", function() Snacks.picker.lazy() end, desc = "Search for Plugin Spec" },
    { "<leader>sq", function() Snacks.picker.qflist() end, desc = "Quickfix List" },
    { "<leader>sR", function() Snacks.picker.resume() end, desc = "Resume" },
    { "<leader>su", function() Snacks.picker.undo() end, desc = "Undo History" },
    { "<leader>uC", function() Snacks.picker.colorschemes() end, desc = "Colorschemes" },
    -- LSP
    { "gd", function() Snacks.picker.lsp_definitions() end, desc = "Goto Definition" },
    { "gD", function() Snacks.picker.lsp_declarations() end, desc = "Goto Declaration" },
    { "gr", function() Snacks.picker.lsp_references() end, nowait = true, desc = "References" },
    { "gI", function() Snacks.picker.lsp_implementations() end, desc = "Goto Implementation" },
    { "gy", function() Snacks.picker.lsp_type_definitions() end, desc = "Goto T[y]pe Definition" },
    { "gai", function() Snacks.picker.lsp_incoming_calls() end, desc = "C[a]lls Incoming" },
    { "gao", function() Snacks.picker.lsp_outgoing_calls() end, desc = "C[a]lls Outgoing" },
    { "<leader>ss", function() Snacks.picker.lsp_symbols() end, desc = "LSP Symbols" },
    { "<leader>sS", function() Snacks.picker.lsp_workspace_symbols() end, desc = "LSP Workspace Symbols" },
    -- Other
    { "<leader>z",  function() Snacks.zen() end, desc = "Toggle Zen Mode" },
    { "<leader>Z",  function() Snacks.zen.zoom() end, desc = "Toggle Zoom" },
    { "<leader>.",  function() Snacks.scratch() end, desc = "Toggle Scratch Buffer" },
    { "<leader>S",  function() Snacks.scratch.select() end, desc = "Select Scratch Buffer" },
    { "<leader>n",  function() Snacks.notifier.show_history() end, desc = "Notification History" },
    { "<leader>bd", function() Snacks.bufdelete() end, desc = "Delete Buffer" },
    { "<leader>cR", function() Snacks.rename.rename_file() end, desc = "Rename File" },
    { "<leader>gB", function() Snacks.gitbrowse() end, desc = "Git Browse", mode = { "n", "v" } },
    { "<leader>gg", function() Snacks.lazygit() end, desc = "Lazygit" },
    { "<leader>un", function() Snacks.notifier.hide() end, desc = "Dismiss All Notifications" },
    { "<c-/>",      function() Snacks.terminal() end, desc = "Toggle Terminal" },
    { "<c-_>",      function() Snacks.terminal() end, desc = "which_key_ignore" },
    { "]]",         function() Snacks.words.jump(vim.v.count1) end, desc = "Next Reference", mode = { "n", "t" } },
    { "[[",         function() Snacks.words.jump(-vim.v.count1) end, desc = "Prev Reference", mode = { "n", "t" } },
    {
      "<leader>N",
      desc = "Neovim News",
      function()
        Snacks.win({
          file = vim.api.nvim_get_runtime_file("doc/news.txt", false)[1],
          width = 0.6,
          height = 0.6,
          wo = {
            spell = false,
            wrap = false,
            signcolumn = "yes",
            statuscolumn = " ",
            conceallevel = 3,
          },
        })
      end,
    }
  },
  init = function()
    vim.api.nvim_create_autocmd("User", {
      pattern = "VeryLazy",
      callback = function()
        -- Setup some globals for debugging (lazy-loaded)
        _G.dd = function(...)
          Snacks.debug.inspect(...)
        end
        _G.bt = function()
          Snacks.debug.backtrace()
        end

        -- Override print to use snacks for `:=` command
        if vim.fn.has("nvim-0.11") == 1 then
          vim._print = function(_, ...)
            dd(...)
          end
        else
          vim.print = _G.dd 
        end

        -- Create some toggle mappings
        Snacks.toggle.option("spell", { name = "Spelling" }):map("<leader>us")
        Snacks.toggle.option("wrap", { name = "Wrap" }):map("<leader>uw")
        Snacks.toggle.option("relativenumber", { name = "Relative Number" }):map("<leader>uL")
        Snacks.toggle.diagnostics():map("<leader>ud")
        Snacks.toggle.line_number():map("<leader>ul")
        Snacks.toggle.option("conceallevel", { off = 0, on = vim.o.conceallevel > 0 and vim.o.conceallevel or 2 }):map("<leader>uc")
        Snacks.toggle.treesitter():map("<leader>uT")
        Snacks.toggle.option("background", { off = "light", on = "dark", name = "Dark Background" }):map("<leader>ub")
        Snacks.toggle.inlay_hints():map("<leader>uh")
        Snacks.toggle.indent():map("<leader>ug")
        Snacks.toggle.dim():map("<leader>uD")
      end,
    })
  end,
}

🌈 Highlight Groups

Snacks defines a lot of highlight groups and it's impossible to document them all.

Instead, you can use the picker to see all the highlight groups.

Snacks.picker.highlights({pattern = "hl_group:^Snacks"})

coder/claudecode.nvim

🧩 Claude Code Neovim IDE Extension

claudecode.nvim

The first Neovim IDE integration for Claude Code — bringing Anthropic's AI coding assistant to your favorite editor with a pure Lua implementation.

🎯 TL;DR: When Anthropic released Claude Code with VS Code and JetBrains support, I reverse-engineered their extension and built this Neovim plugin. This plugin implements the same WebSocket-based MCP protocol, giving Neovim users the same AI-powered coding experience.

https://github.com/user-attachments/assets/9c310fb5-5a23-482b-bedc-e21ae457a82d

What Makes This Special

When Anthropic released Claude Code, they only supported VS Code and JetBrains. As a Neovim user, I wanted the same experience — so I reverse-engineered their extension and built this.

🚀 Pure Lua, Zero Dependencies — Built entirely with vim.loop and Neovim built-ins
🔌 100% Protocol Compatible — Same WebSocket MCP implementation as official extensions
🎓 Fully Documented Protocol — Learn how to build your own integrations (see PROTOCOL.md)
⚡ First to Market — Beat Anthropic to releasing Neovim support
🛠️ Built with AI — Used Claude to reverse-engineer Claude's own protocol

Installation

{
  "coder/claudecode.nvim",
  dependencies = { "folke/snacks.nvim" },
  config = true,
  keys = {
    { "<leader>a", nil, desc = "AI/Claude Code" },
    { "<leader>ac", "<cmd>ClaudeCode<cr>", desc = "Toggle Claude" },
    { "<leader>af", "<cmd>ClaudeCodeFocus<cr>", desc = "Focus Claude" },
    { "<leader>ar", "<cmd>ClaudeCode --resume<cr>", desc = "Resume Claude" },
    { "<leader>aC", "<cmd>ClaudeCode --continue<cr>", desc = "Continue Claude" },
    { "<leader>am", "<cmd>ClaudeCodeSelectModel<cr>", desc = "Select Claude model" },
    { "<leader>ab", "<cmd>ClaudeCodeAdd %<cr>", desc = "Add current buffer" },
    { "<leader>as", "<cmd>ClaudeCodeSend<cr>", mode = "v", desc = "Send to Claude" },
    {
      "<leader>as",
      "<cmd>ClaudeCodeTreeAdd<cr>",
      desc = "Add file",
      ft = { "NvimTree", "neo-tree", "oil", "minifiles", "netrw" },
    },
    -- Diff management
    { "<leader>aa", "<cmd>ClaudeCodeDiffAccept<cr>", desc = "Accept diff" },
    { "<leader>ad", "<cmd>ClaudeCodeDiffDeny<cr>", desc = "Deny diff" },
  },
}

That's it! The plugin will auto-configure everything else.

Requirements

Neovim >= 0.8.0
Claude Code CLI installed
folke/snacks.nvim for enhanced terminal support

Local Installation Configuration

If you've used Claude Code's migrate-installer command to move to a local installation, you'll need to configure the plugin to use the local path.

What is a Local Installation?

Claude Code offers a claude migrate-installer command that:

Moves Claude Code from a global npm installation to ~/.claude/local/
Avoids permission issues with system directories
Creates shell aliases but these may not be available to Neovim

Detecting Your Installation Type

Check your installation type:

# Check where claude command points
which claude

# Global installation shows: /usr/local/bin/claude (or similar)
# Local installation shows: alias to ~/.claude/local/claude

# Verify installation health
claude doctor

Configuring for Local Installation

If you have a local installation, configure the plugin with the direct path:

{
  "coder/claudecode.nvim",
  dependencies = { "folke/snacks.nvim" },
  opts = {
    terminal_cmd = "~/.claude/local/claude", -- Point to local installation
  },
  config = true,
  keys = {
    -- Your keymaps here
  },
}

Native Binary Installation (Alpha)

Claude Code also offers an experimental native binary installation method currently in alpha testing. This provides a single executable with no Node.js dependencies.

Installation Methods

Install the native binary using one of these methods:

# Fresh install (recommended)
curl -fsSL claude.ai/install.sh | bash

# From existing Claude Code installation
claude install

Platform Support

macOS: Full support for Intel and Apple Silicon
Linux: x64 and arm64 architectures
Windows: Via WSL (Windows Subsystem for Linux)

Benefits

Zero Dependencies: Single executable file with no external requirements
Cross-Platform: Consistent experience across operating systems
Secure Installation: Includes checksum verification and automatic cleanup

Configuring for Native Binary

The exact binary path depends on your shell integration. To find your installation:

# Check where claude command points
which claude

# Verify installation type and health
claude doctor

Configure the plugin with the detected path:

{
  "coder/claudecode.nvim",
  dependencies = { "folke/snacks.nvim" },
  opts = {
    terminal_cmd = "/path/to/your/claude", -- Use output from 'which claude'
  },
  config = true,
  keys = {
    -- Your keymaps here
  },
}

Note: If Claude Code was installed globally via npm, you can use the default configuration without specifying terminal_cmd.

Quick Demo

" Launch Claude Code in a split
:ClaudeCode

" Claude now sees your current file and selections in real-time!

" Send visual selection as context
:'<,'>ClaudeCodeSend

" Claude can open files, show diffs, and more

Usage

Launch Claude: Run :ClaudeCode to open Claude in a split terminal
Send context:
- Select text in visual mode and use <leader>as to send it to Claude
- In nvim-tree/neo-tree/oil.nvim/mini.nvim, press <leader>as on a file to add it to Claude's context
Let Claude work: Claude can now:
- See your current file and selections in real-time
- Open files in your editor
- Show diffs with proposed changes
- Access diagnostics and workspace info

Key Commands

:ClaudeCode - Toggle the Claude Code terminal window
:ClaudeCodeFocus - Smart focus/toggle Claude terminal
:ClaudeCodeSelectModel - Select Claude model and open terminal with optional arguments
:ClaudeCodeSend - Send current visual selection to Claude
:ClaudeCodeAdd <file-path> [start-line] [end-line] - Add specific file to Claude context with optional line range
:ClaudeCodeDiffAccept - Accept diff changes
:ClaudeCodeDiffDeny - Reject diff changes

Working with Diffs

When Claude proposes changes, the plugin opens a native Neovim diff view:

Accept: :w (save) or <leader>aa
Reject: :q or <leader>ad

You can edit Claude's suggestions before accepting them.

How It Works

This plugin creates a WebSocket server that Claude Code CLI connects to, implementing the same protocol as the official VS Code extension. When you launch Claude, it automatically detects Neovim and gains full access to your editor.

The protocol uses a WebSocket-based variant of MCP (Model Context Protocol) that:

Creates a WebSocket server on a random port
Writes a lock file to ~/.claude/ide/[port].lock (or $CLAUDE_CONFIG_DIR/ide/[port].lock if CLAUDE_CONFIG_DIR is set) with connection info
Sets environment variables that tell Claude where to connect
Implements MCP tools that Claude can call

📖 Read the full reverse-engineering story → 🔧 Complete protocol documentation →

Architecture

Built with pure Lua and zero external dependencies:

WebSocket Server - RFC 6455 compliant implementation using vim.loop
MCP Protocol - Full JSON-RPC 2.0 message handling
Lock File System - Enables Claude CLI discovery
Selection Tracking - Real-time context updates
Native Diff Support - Seamless file comparison

For deep technical details, see ARCHITECTURE.md.

Advanced Configuration

{
  "coder/claudecode.nvim",
  dependencies = { "folke/snacks.nvim" },
  opts = {
    -- Server Configuration
    port_range = { min = 10000, max = 65535 },
    auto_start = true,
    log_level = "info", -- "trace", "debug", "info", "warn", "error"
    terminal_cmd = nil, -- Custom terminal command (default: "claude")
                        -- For local installations: "~/.claude/local/claude"
                        -- For native binary: use output from 'which claude'

    -- Send/Focus Behavior
    -- When true, successful sends will focus the Claude terminal if already connected
    focus_after_send = false,

    -- Selection Tracking
    track_selection = true,
    visual_demotion_delay_ms = 50,

    -- Terminal Configuration
    terminal = {
      split_side = "right", -- "left" or "right"
      split_width_percentage = 0.30,
      provider = "auto", -- "auto", "snacks", "native", "external", "none", or custom provider table
      auto_close = true,
      snacks_win_opts = {}, -- Opts to pass to `Snacks.terminal.open()` - see Floating Window section below

      -- Provider-specific options
      provider_opts = {
        -- Command for external terminal provider. Can be:
        -- 1. String with %s placeholder: "alacritty -e %s" (backward compatible)
        -- 2. String with two %s placeholders: "alacritty --working-directory %s -e %s" (cwd, command)
        -- 3. Function returning command: function(cmd, env) return "alacritty -e " .. cmd end
        external_terminal_cmd = nil,
      },
    },

    -- Diff Integration
    diff_opts = {
      layout = "vertical", -- "vertical" or "horizontal"
      open_in_new_tab = false,
      keep_terminal_focus = false, -- If true, moves focus back to terminal after diff opens
      hide_terminal_in_new_tab = false,
      -- on_new_file_reject = "keep_empty", -- "keep_empty" or "close_window"

      -- Legacy aliases (still supported):
      -- vertical_split = true,
      -- open_in_current_tab = true,
    },
  },
  keys = {
    -- Your keymaps here
  },
}

Working Directory Control

You can fix the Claude terminal's working directory regardless of autochdir and buffer-local cwd changes. Options (precedence order):

cwd_provider(ctx): function that returns a directory string. Receives { file, file_dir, cwd }.
cwd: static path to use as working directory.
git_repo_cwd = true: resolves git root from the current file directory (or cwd if no file).

Examples:

require("claudecode").setup({
  -- Top-level aliases are supported and forwarded to terminal config
  git_repo_cwd = true,
})

require("claudecode").setup({
  terminal = {
    cwd = vim.fn.expand("~/projects/my-app"),
  },
})

require("claudecode").setup({
  terminal = {
    cwd_provider = function(ctx)
      -- Prefer repo root; fallback to file's directory
      local cwd = require("claudecode.cwd").git_root(ctx.file_dir or ctx.cwd) or ctx.file_dir or ctx.cwd
      return cwd
    end,
  },
})

Floating Window Configuration

The snacks_win_opts configuration allows you to create floating Claude Code terminals with custom positioning, sizing, and key bindings. Here are several practical examples:

Basic Floating Window with Ctrl+, Toggle

local toggle_key = "<C-,>"
return {
  {
    "coder/claudecode.nvim",
    dependencies = { "folke/snacks.nvim" },
    keys = {
      { toggle_key, "<cmd>ClaudeCodeFocus<cr>", desc = "Claude Code", mode = { "n", "x" } },
    },
    opts = {
      terminal = {
        ---@module "snacks"
        ---@type snacks.win.Config|{}
        snacks_win_opts = {
          position = "float",
          width = 0.9,
          height = 0.9,
          keys = {
            claude_hide = {
              toggle_key,
              function(self)
                self:hide()
              end,
              mode = "t",
              desc = "Hide",
            },
          },
        },
      },
    },
  },
}

Alternative with Meta+, (Alt+,) Toggle

local toggle_key = "<M-,>"  -- Alt/Meta + comma
return {
  {
    "coder/claudecode.nvim",
    dependencies = { "folke/snacks.nvim" },
    keys = {
      { toggle_key, "<cmd>ClaudeCodeFocus<cr>", desc = "Claude Code", mode = { "n", "x" } },
    },
    opts = {
      terminal = {
        snacks_win_opts = {
          position = "float",
          width = 0.8,
          height = 0.8,
          border = "rounded",
          keys = {
            claude_hide = { toggle_key, function(self) self:hide() end, mode = "t", desc = "Hide" },
          },
        },
      },
    },
  },
}

Centered Floating Window with Custom Styling

require("claudecode").setup({
  terminal = {
    snacks_win_opts = {
      position = "float",
      width = 0.6,
      height = 0.6,
      border = "double",
      backdrop = 80,
      keys = {
        claude_hide = { "<Esc>", function(self) self:hide() end, mode = "t", desc = "Hide" },
        claude_close = { "q", "close", mode = "n", desc = "Close" },
      },
    },
  },
})

Multiple Key Binding Options

{
  "coder/claudecode.nvim",
  dependencies = { "folke/snacks.nvim" },
  keys = {
    { "<C-,>", "<cmd>ClaudeCodeFocus<cr>", desc = "Claude Code (Ctrl+,)", mode = { "n", "x" } },
    { "<M-,>", "<cmd>ClaudeCodeFocus<cr>", desc = "Claude Code (Alt+,)", mode = { "n", "x" } },
    { "<leader>tc", "<cmd>ClaudeCodeFocus<cr>", desc = "Toggle Claude", mode = { "n", "x" } },
  },
  opts = {
    terminal = {
      snacks_win_opts = {
        position = "float",
        width = 0.85,
        height = 0.85,
        border = "rounded",
        keys = {
          -- Multiple ways to hide from terminal mode
          claude_hide_ctrl = { "<C-,>", function(self) self:hide() end, mode = "t", desc = "Hide (Ctrl+,)" },
          claude_hide_alt = { "<M-,>", function(self) self:hide() end, mode = "t", desc = "Hide (Alt+,)" },
          claude_hide_esc = { "<C-\\><C-n>", function(self) self:hide() end, mode = "t", desc = "Hide (Ctrl+\\)" },
        },
      },
    },
  },
}

Window Position Variations

-- Bottom floating (like a drawer)
snacks_win_opts = {
  position = "bottom",
  height = 0.4,
  width = 1.0,
  border = "single",
}

-- Side floating panel
snacks_win_opts = {
  position = "right",
  width = 0.4,
  height = 1.0,
  border = "rounded",
}

-- Small centered popup
snacks_win_opts = {
  position = "float",
  width = 120,  -- Fixed width in columns
  height = 30,  -- Fixed height in rows
  border = "double",
  backdrop = 90,
}

For complete configuration options, see:

Terminal Providers

None (No-Op) Provider

Run Claude Code without any terminal management inside Neovim. This is useful for advanced setups where you manage the CLI externally (tmux, kitty, separate terminal windows) while still using the WebSocket server and tools.

You have to take care of launching CC and connecting it to the IDE yourself. (e.g. claude --ide or launching claude and then selecting the IDE using the /ide command)

{
  "coder/claudecode.nvim",
  opts = {
    terminal = {
      provider = "none", -- no UI actions; server + tools remain available
    },
  },
}

Notes:

No windows/buffers are created. :ClaudeCode and related commands will not open anything.
The WebSocket server still starts and broadcasts work as usual. Launch the Claude CLI externally when desired.

External Terminal Provider

Run Claude Code in a separate terminal application outside of Neovim:

-- Using a string template (simple)
{
  "coder/claudecode.nvim",
  opts = {
    terminal = {
      provider = "external",
      provider_opts = {
        external_terminal_cmd = "alacritty -e %s", -- %s is replaced with claude command
        -- Or with working directory: "alacritty --working-directory %s -e %s" (first %s = cwd, second %s = command)
      },
    },
  },
}

-- Using a function for dynamic command generation (advanced)
{
  "coder/claudecode.nvim",
  opts = {
    terminal = {
      provider = "external",
      provider_opts = {
        external_terminal_cmd = function(cmd, env)
          -- You can build complex commands based on environment or conditions
          if vim.fn.has("mac") == 1 then
            return { "osascript", "-e", string.format('tell app "Terminal" to do script "%s"', cmd) }
          else
            return "alacritty -e " .. cmd
          end
        end,
      },
    },
  },
}

Custom Terminal Providers

You can create custom terminal providers by passing a table with the required functions instead of a string provider name:

require("claudecode").setup({
  terminal = {
    provider = {
      -- Required functions
      setup = function(config)
        -- Initialize your terminal provider
      end,

      open = function(cmd_string, env_table, effective_config, focus)
        -- Open terminal with command and environment
        -- focus parameter controls whether to focus terminal (defaults to true)
      end,

      close = function()
        -- Close the terminal
      end,

      simple_toggle = function(cmd_string, env_table, effective_config)
        -- Simple show/hide toggle
      end,

      focus_toggle = function(cmd_string, env_table, effective_config)
        -- Smart toggle: focus terminal if not focused, hide if focused
      end,

      get_active_bufnr = function()
        -- Return terminal buffer number or nil
        return 123 -- example
      end,

      is_available = function()
        -- Return true if provider can be used
        return true
      end,

      -- Optional functions (auto-generated if not provided)
      toggle = function(cmd_string, env_table, effective_config)
        -- Defaults to calling simple_toggle for backward compatibility
      end,

      _get_terminal_for_test = function()
        -- For testing only, defaults to return nil
        return nil
      end,
    },
  },
})

Custom Provider Example

Here's a complete example using a hypothetical my_terminal plugin:

local my_terminal_provider = {
  setup = function(config)
    -- Store config for later use
    self.config = config
  end,

  open = function(cmd_string, env_table, effective_config, focus)
    if focus == nil then focus = true end

    local my_terminal = require("my_terminal")
    my_terminal.open({
      cmd = cmd_string,
      env = env_table,
      width = effective_config.split_width_percentage,
      side = effective_config.split_side,
      focus = focus,
    })
  end,

  close = function()
    require("my_terminal").close()
  end,

  simple_toggle = function(cmd_string, env_table, effective_config)
    require("my_terminal").toggle()
  end,

  focus_toggle = function(cmd_string, env_table, effective_config)
    local my_terminal = require("my_terminal")
    if my_terminal.is_focused() then
      my_terminal.hide()
    else
      my_terminal.focus()
    end
  end,

  get_active_bufnr = function()
    return require("my_terminal").get_bufnr()
  end,

  is_available = function()
    local ok, _ = pcall(require, "my_terminal")
    return ok
  end,
}

require("claudecode").setup({
  terminal = {
    provider = my_terminal_provider,
  },
})

The custom provider will automatically fall back to the native provider if validation fails or is_available() returns false.

Note: If your command or working directory may contain spaces or special characters, prefer returning a table of args from a function (e.g., { "alacritty", "--working-directory", cwd, "-e", "claude", "--help" }) to avoid shell-quoting issues.

Community Extensions

The following are third-party community extensions that complement claudecode.nvim. These extensions are not affiliated with Coder and are maintained independently by community members. We do not ensure that these extensions work correctly or provide support for them.

🔍 claude-fzf.nvim

Integrates fzf-lua's file selection with claudecode.nvim's context management:

Batch file selection with fzf-lua multi-select
Smart search integration with grep → Claude
Tree-sitter based context extraction
Support for files, buffers, git files

📚 claude-fzf-history.nvim

Provides convenient Claude interaction history management and access for enhanced workflow continuity.

Disclaimer: These community extensions are developed and maintained by independent contributors. The authors and their extensions are not affiliated with Coder. Use at your own discretion and refer to their respective repositories for installation instructions, documentation, and support.

Auto-Save Plugin Issues

Using auto-save plugins can cause diff windows opened by Claude to immediately accept without waiting for input. You can avoid this using a custom condition:

Pocco81/auto-save.nvim

opts = {
  -- ... other options
  condition = function(buf)
    local fn = vim.fn
    local utils = require("auto-save.utils.data")

    -- First check the default conditions
    if not (fn.getbufvar(buf, "&modifiable") == 1 and utils.not_in(fn.getbufvar(buf, "&filetype"), {})) then
      return false
    end

    -- Exclude claudecode diff buffers by buffer name patterns
    local bufname = vim.api.nvim_buf_get_name(buf)
    if bufname:match("%(proposed%)") or
       bufname:match("%(NEW FILE %- proposed%)") or
       bufname:match("%(New%)") then
      return false
    end

    -- Exclude by buffer variables (claudecode sets these)
    if vim.b[buf].claudecode_diff_tab_name or
       vim.b[buf].claudecode_diff_new_win or
       vim.b[buf].claudecode_diff_target_win then
      return false
    end

    -- Exclude by buffer type (claudecode diff buffers use "acwrite")
    local buftype = fn.getbufvar(buf, "&buftype")
    if buftype == "acwrite" then
      return false
    end

    return true -- Safe to auto-save
  end,
},

okuuva/auto-save.nvim

opts = {
  -- ... other options
  condition = function(buf)
    -- Exclude claudecode diff buffers by buffer name patterns
    local bufname = vim.api.nvim_buf_get_name(buf)
    if bufname:match('%(proposed%)') or bufname:match('%(NEW FILE %- proposed%)') or bufname:match('%(New%)') then
      return false
    end

    -- Exclude by buffer variables (claudecode sets these)
    if
      vim.b[buf].claudecode_diff_tab_name
      or vim.b[buf].claudecode_diff_new_win
      or vim.b[buf].claudecode_diff_target_win
    then
      return false
    end

    -- Exclude by buffer type (claudecode diff buffers use "acwrite")
    local buftype = vim.fn.getbufvar(buf, '&buftype')
    if buftype == 'acwrite' then
      return false
    end

    return true -- Safe to auto-save
  end,
},

Troubleshooting

Claude not connecting? Check :ClaudeCodeStatus and verify lock file exists in ~/.claude/ide/ (or $CLAUDE_CONFIG_DIR/ide/ if CLAUDE_CONFIG_DIR is set)
Need debug logs? Set log_level = "debug" in opts
Terminal issues? Try provider = "native" if using snacks.nvim
Local installation not working? If you used claude migrate-installer, set terminal_cmd = "~/.claude/local/claude" in your config. Check which claude vs ls ~/.claude/local/claude to verify your installation type.
Native binary installation not working? If you used the alpha native binary installer, run claude doctor to verify installation health and use which claude to find the binary path. Set terminal_cmd = "/path/to/claude" with the detected path in your config.

Contributing

See DEVELOPMENT.md for build instructions and development guidelines. Tests can be run with make test.

License

MIT

Acknowledgements

Claude Code CLI by Anthropic
Inspired by analyzing the official VS Code extension
Built with assistance from AI (how meta!)

LazyVim/starter

Starter template for LazyVim

💤 LazyVim

A starter template for LazyVim. Refer to the documentation to get started.

GustavEikaas/easy-dotnet.nvim

A fully self-contained Neovim plugin for .NET development. Ships with integrated Roslyn LSP and netcoredbg debugging, offering fast, dependency-free setup and smooth build/test workflows for C# across .NET Core and .NET Framework.

Simplifying .NET development in Neovim

Are you a .NET developer looking to harness the power of Neovim for your daily coding tasks? Look no further! easy-dotnet.nvim is here to streamline your workflow and make .NET development in Neovim a breeze.

Important

This plugin now uses easy-dotnet-server to enable more advanced functionality. As a result, the server may require more frequent updates. Run :Dotnet _server update or dotnet tool install -g EasyDotnet to update it. The plugin will attempt to detect when the server is outdated and notify you. If you encounter any issues, please don't hesitate to file an issue.

📰 Stay updated: Major updates and new features are announced in news.md.
Give it a read periodically to stay in sync with the latest capabilities!

Motivation

As a developer transitioning from Rider to Neovim, I found myself missing the simplicity of running projects with just a single button click. Tired of typing out lengthy terminal commands for common tasks like running, testing, and managing user secrets, I decided to create easy-dotnet.nvim. This plugin aims to bridge the gap between the convenience of IDEs like Rider and the flexibility of Neovim.

Features

Roslyn LSP support out of the box — powered by the official .NET Roslyn language server (see LSP details)
Debugger configured out of the box- powered by netcoredbg
Solution, slnx, csproj and fsproj support: Whether its a single project or a solution containing multiple projects easy-dotnet has you covered.
Action Commands: Execute common tasks like building, running, testing, cleaning and restoring with ease.
User Secrets Management: Edit, create, and preview .NET user secrets directly within Neovim.
Test runner: Test runner similiar to the one you find in Rider.
Workspace diagnostics: Get diagnostic errors and warnings from your entire solution or individual projects
Outdated command: Makes checking outdated packages a breeze using virtual text
(csproj/fsproj) mappings: Keymappings for .csproj and .fsproj files are automatically available
Auto bootstrap namespace: Automatically inserts namespace and class/interface when opening a newly created .cs file. (also checks clipboard for json to create class from)
Create dotnet templates like with dotnet new, automatically adding them to the current solution
Package autocomplete inside .csproj and .fsproj files Check it out
Rider-like syntax highlighting for injected languages (sql, json and xml) based on comments

Requirements

Neovim needs to be built with LuaJIT
EasyDotnet dotnet tool install -g EasyDotnet

Although not required by the plugin, it is highly recommended to install one of:

Setup

Important

Remember to also setup the cmp source for autocomplete

Without options

-- lazy.nvim
{
  "GustavEikaas/easy-dotnet.nvim",
  dependencies = { "nvim-lua/plenary.nvim", 'folke/snacks.nvim', },
  config = function()
    require("easy-dotnet").setup()
  end
}

With options

-- lazy.nvim
{
  "GustavEikaas/easy-dotnet.nvim",
  -- 'nvim-telescope/telescope.nvim' or 'ibhagwan/fzf-lua' or 'folke/snacks.nvim'
  -- are highly recommended for a better experience
  dependencies = { "nvim-lua/plenary.nvim", 'mfussenegger/nvim-dap', 'folke/snacks.nvim', },
  config = function()
    local dotnet = require("easy-dotnet")
    -- Options are not required
    dotnet.setup({
     managed_terminal = {
       auto_hide = true, -- auto hides terminal if exit code is 0
       auto_hide_delay = 1000, -- delay before auto hiding, 0 = instant
     },
      -- Optional configuration for external terminals (matches nvim-dap structure)
      external_terminal = nil,
      lsp = {
        enabled = true, -- Enable builtin roslyn lsp
        set_fold_expr = false,
        preload_roslyn = true, -- Start loading roslyn before any buffer is opened
        roslynator_enabled = true, -- Automatically enable roslynator analyzer
        easy_dotnet_analyzer_enabled = true, -- Enable roslyn analyzer from easy-dotnet-server
        auto_refresh_codelens = true,
        analyzer_assemblies = {}, -- Any additional roslyn analyzers you might use like SonarAnalyzer.CSharp
        config = {},
      },
      debugger = {
        -- Path to custom coreclr DAP adapter
        -- easy-dotnet-server falls back to its own netcoredbg binary if bin_path is nil
        bin_path = nil,
        console = "integratedTerminal", -- Controls where the target app runs: "integratedTerminal" (Neovim buffer) or "externalTerminal" (OS window)
        apply_value_converters = true,
        auto_register_dap = true,
        mappings = {
          open_variable_viewer = { lhs = "T", desc = "open variable viewer" },
        },
      },
      ---@type TestRunnerOptions
      test_runner = {
        auto_start_testrunner = true,
        hide_legend = false,
        ---@type "split" | "vsplit" | "float" | "buf"
        viewmode = "float",
        ---@type number|nil
        vsplit_width = nil,
        ---@type string|nil "topleft" | "topright" 
        vsplit_pos = nil,
        icons = {
          passed = "",
          skipped = "",
          failed = "",
          success = "",
          reload = "",
          test = "",
          sln = "󰘐",
          project = "󰘐",
          dir = "",
          package = "",
          class = "",
          build_failed = "󰒡",
        },
        mappings = {
          run_test_from_buffer = { lhs = "<leader>r", desc = "run test from buffer" },
          get_build_errors = { lhs = "<leader>e", desc = "get build errors" },
          peek_stack_trace_from_buffer = { lhs = "<leader>p", desc = "peek stack trace from buffer" },
          debug_test_from_buffer = { lhs = "<leader>d", desc = "run test from buffer" },
          debug_test = { lhs = "<leader>d", desc = "debug test" },
          go_to_file = { lhs = "g", desc = "go to file" },
          run_all = { lhs = "<leader>R", desc = "run all tests" },
          run = { lhs = "<leader>r", desc = "run test" },
          peek_stacktrace = { lhs = "<leader>p", desc = "peek stacktrace of failed test" },
          expand = { lhs = "o", desc = "expand" },
          expand_node = { lhs = "E", desc = "expand node" },
          collapse_all = { lhs = "W", desc = "collapse all" },
          close = { lhs = "q", desc = "close testrunner" },
          refresh_testrunner = { lhs = "<C-r>", desc = "refresh testrunner" },
          cancel = { lhs = "<C-c>", desc = "cancel in-flight operation" },
        }
      },
      new = {
        project = {
          prefix = "sln" -- "sln" | "none"
        }
      },
      csproj_mappings = true,
      fsproj_mappings = true,
      auto_bootstrap_namespace = {
          --block_scoped, file_scoped
          type = "block_scoped",
          enabled = true,
          use_clipboard_json = {
            behavior = "prompt", --'auto' | 'prompt' | 'never',
            register = "+", -- which register to check
          },
      },
      server = {
          ---@type nil | "Off" | "Critical" | "Error" | "Warning" | "Information" | "Verbose" | "All"
          log_level = nil,
      },
      -- choose which picker to use with the plugin
      -- possible values are "telescope" | "fzf" | "snacks" | "basic"
      -- if no picker is specified, the plugin will determine
      -- the available one automatically with this priority:
      --  snacks -> fzf -> telescope ->  basic
      picker = "snacks",
      background_scanning = true,
      notifications = {
        --Set this to false if you have configured lualine to avoid double logging
        handler = function(start_event)
          local spinner = require("easy-dotnet.ui-modules.spinner").new()
          spinner:start_spinner(start_event.job.name)
          ---@param finished_event JobEvent
          return function(finished_event)
            spinner:stop_spinner(finished_event.result.msg, finished_event.result.level)
          end
        end,
      },
      diagnostics = {
        default_severity = "error",
        setqflist = false,
      },
    })

    -- Example command
    vim.api.nvim_create_user_command('Secrets', function()
      dotnet.secrets()
    end, {})

    -- Example keybinding
    vim.keymap.set("n", "<C-p>", function()
      dotnet.run_project()
    end)
  end
}

Lualine config

local job_indicator = { require("easy-dotnet.ui-modules.jobs").lualine }

require("lualine").setup {
  sections = {
    -- ...
    lualine_a = { "mode", job_indicator },
    -- ...
  },
}

Commands

Lua functions

Legend

<TS> -> Telescope selector
<DArgs> -> Dotnet args (e.g --no-build, --configuration release). Always optional
<TS Default> -> Telescope selector but persists the selection for all future use
<sln> -> Solution file (in some cases .csproj or .fsproj is used as fallback if no .sln file exists)

Function	Description
`dotnet.run_profile()`	`dotnet run --project <TS> --launch-profile <TS>`
`dotnet.run()`	`dotnet run --project <TS> <DArgs>`
`dotnet.run_default()`	`dotnet run --project <TS Default> <DArgs>`
`dotnet.run_profile_default()`	`dotnet run --project <TS Default> --launch-profile <TS> <DArgs>`

`dotnet.debug_profile()`	``
`dotnet.debug_attach()`	``
`dotnet.debug()`	``
`dotnet.debug_default()`	``
`dotnet.debug_profile_default()`	``

`dotnet.build()`	`dotnet build <TS> <DArgs>`
`dotnet.build_solution()`	`dotnet build <sln> <DArgs>`
`dotnet.build_solution_quickfix()`	`dotnet build <sln> <DArgs>` and opens build errors in the quickfix list
`dotnet.build_quickfix()`	`dotnet build <TS> <DArgs>` and opens build errors in the quickfix list
`dotnet.build_default()`	`dotnet build <TS Default> <DArgs>`
`dotnet.build_default_quickfix()`	`dotnet build <TS Default> <DArgs>` and opens build errors in the quickfix list

`dotnet.project_view()`	Opens the project view
`dotnet.project_view_default()`	Opens the project view for your default project

`dotnet.pack()`	`dotnet pack -c release`
`dotnet.push()`	`dotnet pack and push`

`dotnet.test()`	`dotnet test <TS> <DArgs>`
`dotnet.test_solution()`	`dotnet test <TS> <DArgs>`
`dotnet.test_default()`	`dotnet test <TS Default> <DArgs>`

`dotnet.watch()`	`dotnet watch --project <TS> <DArgs>`
`dotnet.watch_default()`	`dotnet watch --project <TS Default> <DArgs>`

`dotnet.restore()`	`dotnet restore <sln> <Dargs>`
`dotnet.clean()`	`dotnet clean <sln> <DArgs>`

`dotnet.remove_package()`
`dotnet.add_package()`

`dotnet.testrunner()`	Shows or hides the testrunner
`dotnet.testrunner_refresh()`	Refreshes the testrunner
`dotnet.testrunner_refresh_build()`	Builds the sln, then refreshes the testrunner

`dotnet.is_dotnet_project()`	Returns `true` if a `.csproj` or `.sln` file is present in the current working directory or subfolders
`dotnet.try_get_selected_solution()`	If a solution is selected, returns `{ basename: string, path: string }`, otherwise `nil`
`dotnet.new()`	Picker for creating a new template based on `Dotnet new`
`dotnet.outdated()`	Runs `Dotnet outdated` in supported file types (`.csproj`, `.fsproj`, `Directory.Packages.props`, `Packages.props`, `Directory.Build.props`) and displays virtual text with the latest package versions.

`dotnet.solution_select(path: string)`	Manually set a solution file for the current working directory. Useful for non-standard layouts where the solution file is outside the normal search depth or in a different location.
`dotnet.solution_add()`	`dotnet sln <sln> add <TS>`.
`dotnet.solution_remove()`	`dotnet sln <sln> remove <TS>`.

`dotnet.ef_migrations_remove()`	Removes the last applied Entity Framework migration
`dotnet.ef_migrations_add(name: string)`	Adds a new Entity Framework migration with the specified name.
`dotnet.ef_migrations_list()`	Lists all applied Entity Framework migrations.
`dotnet.ef_database_drop()`	Drops the database for the selected project.
`dotnet.ef_database_update()`	Updates the database to the latest migration.
`dotnet.ef_database_update_pick()`	Opens a picker to update the database to a selected migration.

`dotnet.createfile(path)`	Spawns a picker for creating a new file based on a `.NET new` template
`dotnet.secrets()`	Opens a picker for `.NET user-secrets`
`dotnet.get_debug_dll()`	Returns the DLL from the `bin/debug` folder
`dotnet.get_environment_variables(project_name, project_path, use_default_launch_profile: boolean)`	Returns the environment variables from the `launchSetting.json` file
`dotnet.reset()`	Deletes all files persisted by `easy-dotnet.nvim`. Use this if unable to pick a different solution or project

`diagnostics.get_workspace_diagnostics()`	Get workspace diagnostics using configured default severity
`diagnostics.get_workspace_diagnostics("error")`	Get workspace diagnostics for errors only
`diagnostics.get_workspace_diagnostics("warning")`	Get workspace diagnostics for errors and warnings

local dotnet = require("easy-dotnet")
dotnet.lsp_start()
dotnet.lsp_restart()
dotnet.lsp_stop()
dotnet.get_environment_variables(project_name, project_path, use_default_launch_profile: boolean)
dotnet.is_dotnet_project()                                 
dotnet.try_get_selected_solution()                         
dotnet.get_debug_dll()                                     
dotnet.reset()                                             
dotnet.test()
dotnet.test_solution()
dotnet.test_default()
dotnet.testrunner()
dotnet.testrunner_refresh()
dotnet.testrunner_refresh_build()
dotnet.new()
dotnet.outdated()
dotnet.add_package()
dotnet.remove_package()
dotnet.solution_select(path: string)
dotnet.ef_migrations_remove()
dotnet.ef_migrations_add(name: string)
dotnet.ef_migrations_list()
dotnet.ef_database_drop()
dotnet.ef_database_update()
dotnet.ef_database_update_pick()
dotnet.createfile(path: string)                                    
dotnet.build()                           
dotnet.build_solution()
dotnet.build_solution_quickfix()
dotnet.build_quickfix()                 
dotnet.build_default()                 
dotnet.build_default_quickfix()       
dotnet.project_view()
dotnet.project_view_default()
dotnet.pack()                           
dotnet.push()                           
dotnet.run()
dotnet.run_profile_default()
dotnet.run_default()
dotnet.watch()
dotnet.watch_default()
dotnet.secrets()                                                          
dotnet.clean()                                                           
dotnet.restore()

local diagnostics = require("easy-dotnet.actions.diagnostics")
diagnostics.get_workspace_diagnostics()
diagnostics.get_workspace_diagnostics("error") 
diagnostics.get_workspace_diagnostics("warning")

Vim commands

Run :Dotnet in nvim to list all commands

Dotnet lsp start
Dotnet lsp restart
Dotnet lsp stop
Dotnet testrunner
Dotnet testrunner refresh
Dotnet testrunner refresh build
Dotnet run
Dotnet run default
Dotnet run profile
Dotnet run profile default
Dotnet debug
Dotnet debug attach
Dotnet debug default
Dotnet debug profile
Dotnet debug profile default
Dotnet watch
Dotnet watch default
Dotnet test
Dotnet test default
Dotnet test solution
Dotnet build
Dotnet build quickfix
Dotnet build solution
Dotnet build solution quickfix
Dotnet build default
Dotnet build default quickfix
Dotnet add package
Dotnet add package prerelease
Dotnet remove package
Dotnet project view
Dotnet project view default
Dotnet pack
Dotnet push
Dotnet ef database update
Dotnet ef database update pick
Dotnet ef database drop
Dotnet ef migrations add
Dotnet ef migrations remove
Dotnet ef migrations list
Dotnet secrets
Dotnet restore
Dotnet clean
Dotnet new
Dotnet createfile
Dotnet solution select <path>
Dotnet solution add
Dotnet solution remove
Dotnet outdated
Dotnet diagnostic
Dotnet diagnostic errors
Dotnet diagnostic warnings
checkhealth easy-dotnet

-- Internal 
Dotnet reset -- Deletes all persisted files
Dotnet _cached_files -- Preview picker for persisted files
Dotnet _server restart
Dotnet _server update
Dotnet _server stop
Dotnet _server start

Roslyn LSP

Roslyn LSP support is enabled out of the box — no configuration required.
Just open a C# file and the official .NET language server starts automatically.

For more information check out

Test runner

Integrated test runner inspired by Rider IDE. Powered by easy-dotnet-server.

If you experience issues with a test adapter please open an issue.

The test runner starts automatically when the server starts and runs discovery silently in the background, so the tree is ready before you open the window.

Keymaps

Key	Action
`o`	Expand / collapse node under cursor
`E`	Expand all
`W`	Collapse all
`<leader>r`	Run test under cursor
`<leader>R`	Run all tests
`<leader>d`	Debug test under cursor
`<leader>p`	Peek stacktrace of failed test
`<leader>g`	Go to file
`<C-r>`	Refresh test runner node
`<C-c>`	Cancel in-flight operation
`q`	Close window

Debugging tests

Use <leader>d on any node in the runner to start a debug session. Breakpoints must be set manually before starting the session.

Running tests from buffer

Gutter signs appear automatically on test methods and classes once discovery has completed.

Key	Action
`<leader>r`	Run test or class under cursor
`<leader>d`	Debug test or class under cursor
`<leader>p`	Peek stacktrace of failed test

When a run is triggered from the buffer the method or class flashes to confirm it was picked up. When the run finishes it flashes again in the colour of the result.

Project view

Get a comprehensive overview of a project's dependencies, and easily manage NuGet packages and project references.

Features

Project Details: View project name, solution, language, and target version.
Project References:
- View project references.
- Add or remove project references.
NuGet Packages:
- View package references.
- Add or remove NuGet package references.

Keymaps

Keymaps are region-specific and work based on context (e.g., when hovering over a project/package or its header):

Project References:

a: Add project reference.
r: Remove project reference.

Package References:

a: Add package reference.
r: Remove package reference.
<C-b>: View package in browser.

Workspace Diagnostics

Analyze your entire solution or individual projects for compilation errors and warnings using Roslyn diagnostics.

Commands

Dotnet diagnostic - Uses the configured default severity (errors by default)
Dotnet diagnostic errors - Shows only compilation errors
Dotnet diagnostic warnings - Shows both errors and warnings

Configuration

require("easy-dotnet").setup({
  diagnostics = {
    default_severity = "error",  -- "error" or "warning" (default: "error")
    setqflist = false,           -- Populate quickfix list automatically (default: false)
  },
})

Features

Solution/Project Selection: When multiple projects or solutions are available, you'll be prompted to select which one to analyze
Roslyn Integration: Uses the Roslyn Language Server Protocol for accurate diagnostics
Neovim Diagnostics Integration: Results are populated into Neovim's built-in diagnostic system, allowing you to:
- Navigate between diagnostics using :lua vim.diagnostic.goto_next() and :lua vim.diagnostic.goto_prev()
- View diagnostics in the quickfix list using :lua vim.diagnostic.setqflist() (or automatically if configured)
- See inline diagnostic messages
- View with trouble (requires trouble.nvim)
- View with snacks diagnostic picker (requires snacks.nvim)

The diagnostics will appear in Neovim's diagnostic system, allowing you to navigate through them using your standard diagnostic keymaps. If you have trouble.nvim or snacks.nvim configured, the diagnostics will automatically be available in their respective interfaces.

Outdated

Run the command Dotnet outdated in one of the supported filetypes, virtual text with packages latest version will appear

Supports the following filetypes

*.csproj
*.fsproj
Directory.Packages.props
Packages.props
Directory.Build.props

Add

Add package

Adding nuget packages are available using the :Dotnet add package command. This will allow you to browse for nuget packages.

Project mappings

Key mappings are available automatically within .csproj and .fsproj files

Add reference

<leader>ar -> Opens a picker for selecting which project reference to add

Package autocomplete

When editing package references inside a .csproject file it is possible to enable autocomplete. This will trigger autocomplete for <PackageReference Include="<cmp-trigger>" Version="<cmp-trigger>" />

Using nvim-cmp

    cmp.register_source("easy-dotnet", require("easy-dotnet").package_completion_source)
    ...
    sources = cmp.config.sources({
        { name = 'nvim_lsp'    },
        { name = 'easy-dotnet' },
        ...
    }),
    ...

Using Blink.cmp

return {
  "saghen/blink.cmp",
  version = "*",
  config = function()
    require("blink.cmp").setup {
      fuzzy = { implementation = "prefer_rust_with_warning" },
      sources = {
        default = { "lsp", "easy-dotnet", "path" },
        providers = {
          ["easy-dotnet"] = {
            name = "easy-dotnet",
            enabled = true,
            module = "easy-dotnet.completion.blink",
            score_offset = 10000,
            async = true,
          },
        },
      },
    }
  end,
}

Note

Latest is added as a snippet to make it easier to select the latest version

.NET Framework

Basic support for .NET framework has been achieved. This means basic functionality like build/run/test/test-runner should work. If you find something not working feel free to file an issue.

Requirements

choco install nuget.commandline
Visual studio installation
options.server.use_visual_studio == true

New

Create dotnet templates as with dotnet new <templatename> Try it out by running Dotnet new

Project

https://github.com/user-attachments/assets/aa067c17-3611-4490-afc8-41d98a526729

Configuration file

If a configuration file is selected it will

Create the configuration file and place it next to your solution file. (solution files and gitignore files are placed in cwd)

Integrating with nvim-tree

Adding the following configuration to your nvim-tree will allow for creating files using dotnet templates

    require("nvim-tree").setup({
      on_attach = function(bufnr)
        local api = require('nvim-tree.api')

        local function opts(desc)
          return { desc = 'nvim-tree: ' .. desc, buffer = bufnr, noremap = true, silent = true, nowait = true }
        end

        vim.keymap.set('n', 'A', function()
          local node = api.tree.get_node_under_cursor()
          local path = node.type == "directory" and node.absolute_path or vim.fs.dirname(node.absolute_path)
          require("easy-dotnet").create_new_item(path)
        end, opts('Create file from dotnet template'))
      end
    })

Integrating with neo-tree

Adding the following configuration to your neo-tree will allow for creating files using dotnet templates

      require("neo-tree").setup({
      ---...other options
        filesystem = {
          window = {
            mappings = {
              -- Make the mapping anything you want
              ["R"] = "easy",
            },
          },
          commands = {
            ["easy"] = function(state)
              local node = state.tree:get_node()
              local path = node.type == "directory" and node.path or vim.fs.dirname(node.path)
              require("easy-dotnet").create_new_item(path, function()
                require("neo-tree.sources.manager").refresh(state.name)
              end)
            end
          }
        },
      })

Integrating with mini files

Adding the following autocmd to your config will allow for creating files using dotnet templates

    vim.api.nvim_create_autocmd("User", {
      pattern = "MiniFilesBufferCreate",
      callback = function(args)
        local buf_id = args.data.buf_id
        vim.keymap.set("n", "<leader>a", function()
          local entry = require("mini.files").get_fs_entry()
          if entry == nil then
            vim.notify("No fd entry in mini files", vim.log.levels.WARN)
            return
          end
          local target_dir = entry.path
          if entry.fs_type == "file" then
            target_dir = vim.fn.fnamemodify(entry.path, ":h")
          end
          require("easy-dotnet").create_new_item(target_dir)
        end, { buffer = buf_id, desc = "Create file from dotnet template" })
      end,
    })

Integrating with snacks explorer

  {
    "folke/snacks.nvim",
    ---@type snacks.Config
    opts = {
      picker = {
        sources = {
          explorer = {
            win = {
              list = {
                keys = {
                  ["A"] = "explorer_add_dotnet",
                },
              },
            },
            actions = {
              explorer_add_dotnet = function(picker)
                local dir = picker:dir()
                local easydotnet = require("easy-dotnet")

                easydotnet.create_new_item(dir, function(item_path)
                  local tree = require("snacks.explorer.tree")
                  local actions = require("snacks.explorer.actions")
                  tree:open(dir)
                  tree:refresh(dir)
                  actions.update(picker, { target = item_path })
                  picker:focus()
                end)
              end,
            },
          },
        },
      },
    },
  },

EntityFramework

Common EntityFramework commands have been added mainly to reduce the overhead of writing --project .. --startup-project ...

Requirements

This functionality relies on dotnet-ef tool, install using dotnet tool install --global dotnet-ef

Database

Dotnet ef database update
Dotnet ef database update pick --allows to pick which migration to apply
Dotnet ef database drop

Migrations

Dotnet ef migrations add <name>
Dotnet ef migrations remove
Dotnet ef migrations list

Language injections

Rider-like syntax highlighting for injected languages (sql, json and xml) based on comments.

Just add single-line comment like //language=json before string to start using this.

Showcase

Language injection with raw json string as an example.

Requirements

This functionality is based on Treesitter and parsers for sql, json and xml, so make sure you have these parsers installed: :TSInstall sql json xml.

Support matrix

Strings

string	sql	json	xml
quoted	✅	❌	✅
verbatim	✅	❌	✅
raw	✅	✅	✅
regexp quoted	❌	❌	❌
regexp verbatim	❌	❌	❌
regexp raw	❌	❌	❌

Interpolated strings

interpolated string	json	xml
quoted	❌	❌
verbatim	❌	❌
raw	✅	✅
regexp quoted	❌	❌
regexp verbatim	❌	❌
regexp raw	❌	❌

Nvim-dap configuration

Check out debugging-setup for a full walkthrough of debugging setup

Troubleshooting

Update the plugin to latest version
Run :checkhealth easy-dotnet

Highlight groups

Click to see all highlight groups

Highlight group	Default
EasyDotnetTestRunnerSolution	Question
EasyDotnetTestRunnerProject	Character
EasyDotnetTestRunnerTest	Normal
EasyDotnetTestRunnerSubcase	Conceal
EasyDotnetTestRunnerDir	Directory
EasyDotnetTestRunnerPackage	Include
EasyDotnetTestRunnerPassed	DiagnosticOk
EasyDotnetTestRunnerFailed	DiagnosticError
EasyDotnetTestRunnerRunning	DiagnosticWarn
EasyDotnetDebuggerFloatVariable	Question
EasyDotnetDebuggerVirtualVariable	Question
EasyDotnetDebuggerVirtualException	DiagnosticError
EasyDotnetPeekTitle	Custom (Accent)
EasyDotnetPeekBorder	Custom (Accent)
EasyDotnetPeekMain	Custom (Dark)
EasyDotnetPeekSideBar	Custom (Darker)
EasyDotnetPeekWinBar	Custom (Dark)
EasyDotnetPeekHint	Custom (Italic Gray)
EasyDotnetPeekListActive	Custom (Blue)

Local Development

Check out setup guide

Star History

Contributors

esmuellert/codediff.nvim

A Neovim plugin that provides VSCode-style diff rendering with two-tier highlighting (line + character level) in side-by-side and inline layouts, using VSCode's algorithm implemented in C.

codediff.nvim

A Neovim plugin that provides VSCode-style diff rendering with two-tier highlighting, supporting both side-by-side and inline (unified) layouts.

https://github.com/user-attachments/assets/64c41f01-dffe-4318-bce4-16eec8de356e

Demo: Quick walkthrough of diff features

Features

Two-tier highlighting system:
- Light backgrounds for entire modified lines (green for insertions, red for deletions)
- Deep/dark character-level highlights showing exact changes within lines
Side-by-side diff view in a new tab with synchronized scrolling
Inline (unified) diff view — single-window layout with deleted lines as virtual overlays, with treesitter syntax highlighting
Toggle layout — switch between side-by-side and inline layout at runtime with t
Git integration: Compare between any git revision (HEAD, commits, branches, tags)
Same implementation as VSCode's diff engine, providing identical visual highlighting for most scenarios
Fast C-based diff computation using FFI with multi-core parallelization (OpenMP)
Async git operations - non-blocking file retrieval from git
Moved code detection — identifies blocks of code that moved within a file, with visual indicators (highlights, signs, annotations) matching VSCode's experimental showMoves feature (opt-in)

Installation

Prerequisites

Neovim >= 0.7.0 (for Lua FFI support; 0.10+ recommended for vim.system)
Git (for git diff features)
curl or wget (for automatic binary download) No compiler required! The plugin automatically downloads pre-built binaries from GitHub releases.

Using lazy.nvim

Minimal installation:

{
  "esmuellert/codediff.nvim",
  cmd = "CodeDiff",
}

Note: The plugin automatically adapts to your colorscheme's background (dark/light). It uses DiffAdd and DiffDelete for line-level diffs, and auto-adjusts brightness for character-level highlights (1.4x brighter for dark themes, 0.92x darker for light themes). See Highlight Groups for customization.

With custom configuration:

{
  "esmuellert/codediff.nvim",
  cmd = "CodeDiff",
  opts = {
    -- Highlight configuration
    highlights = {
      -- Line-level: accepts highlight group names or hex colors (e.g., "#2ea043")
      line_insert = "DiffAdd",      -- Line-level insertions
      line_delete = "DiffDelete",   -- Line-level deletions

      -- Character-level: accepts highlight group names or hex colors
      -- If specified, these override char_brightness calculation
      char_insert = nil,            -- Character-level insertions (nil = auto-derive)
      char_delete = nil,            -- Character-level deletions (nil = auto-derive)

      -- Brightness multiplier (only used when char_insert/char_delete are nil)
      -- nil = auto-detect based on background (1.4 for dark, 0.92 for light)
      char_brightness = nil,        -- Auto-adjust based on your colorscheme

      -- Conflict sign highlights (for merge conflict views)
      -- Accepts highlight group names or hex colors (e.g., "#f0883e")
      -- nil = use default fallback chain
      conflict_sign = nil,          -- Unresolved: DiagnosticSignWarn -> #f0883e
      conflict_sign_resolved = nil, -- Resolved: Comment -> #6e7681
      conflict_sign_accepted = nil, -- Accepted: GitSignsAdd -> DiagnosticSignOk -> #3fb950
      conflict_sign_rejected = nil, -- Rejected: GitSignsDelete -> DiagnosticSignError -> #f85149
    },

    -- Diff view behavior
    diff = {
      layout = "side-by-side",             -- Diff layout: "side-by-side" (two panes) or "inline" (single pane with virtual lines)
      disable_inlay_hints = true,         -- Disable inlay hints in diff windows for cleaner view
      max_computation_time_ms = 5000,     -- Maximum time for diff computation (VSCode default)
      ignore_trim_whitespace = false,     -- Ignore leading/trailing whitespace changes (like diffopt+=iwhite)
      hide_merge_artifacts = false,       -- Hide merge tool temp files (*.orig, *.BACKUP.*, *.BASE.*, *.LOCAL.*, *.REMOTE.*)
      original_position = "left",         -- Position of original (old) content: "left" or "right"
      conflict_ours_position = "right",   -- Position of ours (:2) in conflict view: "left" or "right"
      conflict_result_position = "bottom", -- "bottom" (default): result below diff panes or "center": result between diff panes (three columns)
      conflict_result_height = 30,         -- Height of result pane in bottom layout (% of total height)
      conflict_result_width_ratio = { 1, 1, 1 }, -- Width ratio for center layout panes {left, center, right} (e.g., {1, 2, 1} for wider result)
      cycle_next_hunk = true,             -- Wrap around when navigating hunks (]c/[c): false to stop at first/last
      cycle_next_file = true,             -- Wrap around when navigating files (]f/[f): false to stop at first/last
      jump_to_first_change = true,        -- Auto-scroll to first change when opening a diff: false to stay at same line
      highlight_priority = 100,           -- Priority for line-level diff highlights (increase to override LSP highlights)
      compute_moves = false,              -- Detect moved code blocks (opt-in, matches VSCode experimental.showMoves)
    },

    -- Explorer panel configuration
    explorer = {
      position = "left",  -- "left" or "bottom"
      width = 40,         -- Width when position is "left" (columns)
      height = 15,        -- Height when position is "bottom" (lines)
      indent_markers = true,  -- Show indent markers in tree view (│, ├, └)
      initial_focus = "explorer",  -- Initial focus: "explorer", "original", or "modified"
      icons = {
        folder_closed = "",  -- Nerd Font folder icon (customize as needed)
        folder_open = "",    -- Nerd Font folder-open icon
      },
      view_mode = "list",    -- "list" or "tree"
      flatten_dirs = true,   -- Flatten single-child directory chains in tree view
      file_filter = {
        ignore = { ".git/**", ".jj/**" },  -- Glob patterns to hide (e.g., {"*.lock", "dist/*"})
      },
      focus_on_select = false,  -- Jump to modified pane after selecting a file (default: stay in explorer)
      visible_groups = {       -- Which groups to show (can be toggled at runtime)
        staged = true,
        unstaged = true,
        conflicts = true,
      },
    },

    -- History panel configuration (for :CodeDiff history)
    history = {
      position = "bottom",  -- "left" or "bottom" (default: bottom)
      width = 40,           -- Width when position is "left" (columns)
      height = 15,          -- Height when position is "bottom" (lines)
      initial_focus = "history",  -- Initial focus: "history", "original", or "modified"
      view_mode = "list",   -- "list" or "tree" for files under commits
    },

    -- Keymaps in diff view
    keymaps = {
      view = {
        quit = "q",                    -- Close diff tab
        toggle_explorer = "<leader>b",  -- Toggle explorer visibility (explorer mode only)
        focus_explorer = "<leader>e",   -- Focus explorer panel (explorer mode only)
        next_hunk = "]c",   -- Jump to next change
        prev_hunk = "[c",   -- Jump to previous change
        next_file = "]f",   -- Next file in explorer/history mode
        prev_file = "[f",   -- Previous file in explorer/history mode
        diff_get = "do",    -- Get change from other buffer (like vimdiff)
        diff_put = "dp",    -- Put change to other buffer (like vimdiff)
        open_in_prev_tab = "gf", -- Open current buffer in previous tab (or create one before)
        close_on_open_in_prev_tab = false, -- Close codediff tab after gf opens file in previous tab
        toggle_stage = "-", -- Stage/unstage current file (works in explorer and diff buffers)
        stage_hunk = "<leader>hs",   -- Stage hunk under cursor to git index
        unstage_hunk = "<leader>hu", -- Unstage hunk under cursor from git index
        discard_hunk = "<leader>hr", -- Discard hunk under cursor (working tree only)
        hunk_textobject = "ih",      -- Textobject for hunk (vih to select, yih to yank, etc.)
        show_help = "g?",   -- Show floating window with available keymaps
        align_move = "gm", -- Temporarily align moved code blocks across panes
        toggle_layout = "t", -- Toggle between side-by-side and inline layout
      },
      explorer = {
        select = "<CR>",    -- Open diff for selected file
        hover = "K",        -- Show file diff preview
        refresh = "R",      -- Refresh git status
        toggle_view_mode = "i",  -- Toggle between 'list' and 'tree' views
        stage_all = "S",    -- Stage all files
        unstage_all = "U",  -- Unstage all files
        restore = "X",      -- Discard changes (restore file)
        toggle_changes = "gu",  -- Toggle Changes (unstaged) group visibility
        toggle_staged = "gs",   -- Toggle Staged Changes group visibility
        -- Fold keymaps (Vim-style)
        fold_open = "zo",           -- Open fold (expand current node)
        fold_open_recursive = "zO", -- Open fold recursively (expand all descendants)
        fold_close = "zc",          -- Close fold (collapse current node)
        fold_close_recursive = "zC", -- Close fold recursively (collapse all descendants)
        fold_toggle = "za",         -- Toggle fold (expand/collapse current node)
        fold_toggle_recursive = "zA", -- Toggle fold recursively
        fold_open_all = "zR",       -- Open all folds in tree
        fold_close_all = "zM",      -- Close all folds in tree
      },
      history = {
        select = "<CR>",    -- Select commit/file or toggle expand
        toggle_view_mode = "i",  -- Toggle between 'list' and 'tree' views
        refresh = "R",      -- Refresh history (re-fetch commits)
        -- Fold keymaps (Vim-style, apply to directory nodes only)
        fold_open = "zo",           -- Open fold (expand current node)
        fold_open_recursive = "zO", -- Open fold recursively (expand all descendants)
        fold_close = "zc",          -- Close fold (collapse current node)
        fold_close_recursive = "zC", -- Close fold recursively (collapse all descendants)
        fold_toggle = "za",         -- Toggle fold (expand/collapse current node)
        fold_toggle_recursive = "zA", -- Toggle fold recursively
        fold_open_all = "zR",       -- Open all folds in tree
        fold_close_all = "zM",      -- Close all folds in tree
      },
      conflict = {
        accept_incoming = "<leader>ct",  -- Accept incoming (theirs/left) change
        accept_current = "<leader>co",   -- Accept current (ours/right) change
        accept_both = "<leader>cb",      -- Accept both changes (incoming first)
        discard = "<leader>cx",          -- Discard both, keep base
        -- Accept all (whole file) - uppercase versions
        accept_all_incoming = "<leader>cT",  -- Accept ALL incoming changes
        accept_all_current = "<leader>cO",   -- Accept ALL current changes
        accept_all_both = "<leader>cB",      -- Accept ALL both changes
        discard_all = "<leader>cX",          -- Discard ALL, reset to base
        next_conflict = "]x",            -- Jump to next conflict
        prev_conflict = "[x",            -- Jump to previous conflict
        diffget_incoming = "2do",        -- Get hunk from incoming (left/theirs) buffer
        diffget_current = "3do",         -- Get hunk from current (right/ours) buffer
      },
    },
  },
}

The C library will be downloaded automatically on first use. No build step needed!

Managing Library Installation

The plugin automatically manages the C library installation:

Automatic Updates:

The library is automatically downloaded on first use
When you update the plugin to a new version, the library is automatically updated to match
No manual intervention required!

Manual Installation Commands:

" Install/update the library manually
:CodeDiff install

" Force reinstall (useful for troubleshooting)
:CodeDiff install!

Version Management: The installer reads the VERSION file to download the matching library version from GitHub releases. This ensures compatibility between the Lua code and C library.

Manual Installation

If you prefer to install manually without a plugin manager:

Clone the repository:

git clone https://github.com/esmuellert/codediff.nvim ~/.local/share/nvim/codediff.nvim

Add to your Neovim runtime path in init.lua:

vim.opt.rtp:append("~/.local/share/nvim/codediff.nvim")

Install the C library:

The plugin requires a C library binary in the plugin root directory. The plugin auto-detects these filenames:

libvscode_diff.so or libvscode_diff_<version>.so (Linux/BSD)
libvscode_diff.dylib or libvscode_diff_<version>.dylib (macOS)
libvscode_diff.dll or libvscode_diff_<version>.dll (Windows)

Option A: Download from GitHub releases (recommended)

Download the appropriate binary from the GitHub releases page and place it in the plugin root directory. Rename it to match the expected format: libvscode_diff.so/.dylib/.dll or libvscode_diff_<version>.so/.dylib/.dll. Linux users: If your system lacks OpenMP, also download libgomp_linux_{arch}_{version}.so.1 and rename it to libgomp.so.1 in the same directory.

Option B: Build from source

Build requirements: C compiler (GCC/Clang/MSVC/MinGW) or CMake 3.15+

Using build scripts (no CMake required):

# Linux/macOS/BSD
./build.sh

# Windows
build.cmd

Or using CMake:

cmake -B build
cmake --build build

Both methods automatically place the library in the plugin root directory.

Usage

The :CodeDiff command supports multiple modes:

File Explorer Mode

Open an interactive file explorer showing changed files:

" Show git status in explorer (default)
:CodeDiff

" Show changes for specific revision in explorer
:CodeDiff HEAD~5

" Compare against a branch
:CodeDiff main

" Compare against a specific commit
:CodeDiff abc123

" Compare two revisions (e.g. HEAD vs main)
:CodeDiff main HEAD

" Override layout for this invocation (works with all subcommands)
:CodeDiff --inline
:CodeDiff main --side-by-side

PR-like Diff (Merge-base)

Show only changes introduced since branching from a base branch—exactly like a Pull Request:

" Compare merge-base(main, HEAD) vs working tree
" Shows only YOUR changes since you branched from main
:CodeDiff main...

" Compare merge-base(main, HEAD) vs HEAD (committed changes only)
:CodeDiff main...HEAD

" Compare merge-base between two branches
:CodeDiff develop...feature/new-ui

This uses git merge-base semantics (equivalent to git diff main...HEAD), showing only the changes introduced on your branch, not changes that happened on the base branch since you branched.

Git Diff Mode

Compare the current buffer with a git revision:

" Compare with last commit
:CodeDiff file HEAD

" Compare with previous commit
:CodeDiff file HEAD~1

" Compare with specific commit
:CodeDiff file abc123

" Compare with branch
:CodeDiff file main

" Compare with tag
:CodeDiff file v1.0.0

" Compare two revisions for current file
:CodeDiff file main HEAD

" PR-like diff: compare merge-base(main, HEAD) vs working tree
:CodeDiff file main...

Requirements:

Current buffer must be saved to a file
File must be in a git repository
Git revision must exist

Behavior:

Left buffer: Git version (at specified revision) - readonly
Right buffer: Current buffer content - readonly
Opens in a new tab automatically
Async operation - won't block Neovim

File Comparison Mode

Compare two arbitrary files side-by-side:

:CodeDiff file file_a.txt file_b.txt

Directory Comparison Mode

Compare two directories without git:

" Auto-detect directories
:CodeDiff ~/project-v1 ~/project-v2

" Explicit dir subcommand
:CodeDiff dir /path/to/dir1 /path/to/dir2

Shows files as Added (A), Deleted (D), or Modified (M) using file size plus byte-level content comparison. Select a file to view its diff.

File History Mode

Review commits on a per-commit basis:

" Show last 50 commits
:CodeDiff history

" Show last N commits
:CodeDiff history HEAD~10

" Show commits in a range (great for PR review)
:CodeDiff history origin/main..HEAD

" Show commits for current file only
:CodeDiff history HEAD~20 %

" Show commits for a specific file
:CodeDiff history HEAD~10 path/to/file.lua

" Show commits in chronological order (oldest first)
:CodeDiff history --reverse
:CodeDiff history HEAD~10 --reverse
:CodeDiff history origin/main..HEAD -r
:CodeDiff history HEAD~20 % --reverse

" Compare each commit against the current working tree
:CodeDiff history --base WORKING

" Compare each commit against HEAD
:CodeDiff history --base HEAD

" Line-range history: show only commits that changed the selected lines
:'<,'>CodeDiff history
:'<,'>CodeDiff history HEAD~10
:'<,'>CodeDiff history --reverse

The history panel shows a list of commits. Each commit can be expanded to show its changed files. Select a file to view the diff between the commit and its parent (commit^ vs commit).

Options:

--reverse or -r: Show commits in chronological order (oldest first) instead of reverse chronological. Useful for following development story from beginning to end, or reviewing PR changes in the order they were made.
--base or -b: Compare each commit against a fixed revision instead of its parent. Accepts any git revision (HEAD, branch name, commit hash) or WORKING for the current working tree.
--inline / --side-by-side: Override the diff layout for this invocation. These flags work with all :CodeDiff subcommands.

Visual selection: When called with a visual range (:'<,'>CodeDiff history), only commits that modified the selected lines are shown. This uses git log -L under the hood and is useful for tracing the evolution of a specific function or block in a large file.

History Keymaps:

i - Toggle between list and tree view for files under commits

Git Merge Tool

Use CodeDiff as your git merge tool for resolving conflicts:

git config --global merge.tool codediff
git config --global mergetool.codediff.cmd 'nvim "$MERGED" -c "CodeDiff merge \"$MERGED\""'

Git Diff Tool

Use CodeDiff as your git diff tool for viewing changes:

git config --global diff.tool codediff
git config --global difftool.codediff.cmd 'nvim "$LOCAL" "$REMOTE" +"CodeDiff file $LOCAL $REMOTE"'

Then use git difftool to view diffs:

git difftool                      # View all uncommitted changes
git difftool HEAD~2 HEAD          # Compare two commits
git difftool main feature-branch  # Compare branches
git difftool -y                   # Skip confirmation prompts

Lua API

-- Primary user API - setup configuration
require("codediff").setup({
  highlights = {
    line_insert = "DiffAdd",
    line_delete = "DiffDelete",
    char_brightness = 1.4,
  },
})

-- Advanced usage - direct access to internal modules
local diff = require("codediff.diff")
local render = require("codediff.ui")
local git = require("codediff.git")

-- Example 1: Compute diff between two sets of lines
local lines_a = {"line 1", "line 2"}
local lines_b = {"line 1", "modified line 2"}
local lines_diff = diff.compute_diff(lines_a, lines_b)

-- Example 2: Get file content from git (async)
git.get_file_content("HEAD~1", "/path/to/repo", "relative/path.lua", function(err, lines)
  if err then
    vim.notify(err, vim.log.levels.ERROR)
    return
  end
  -- Use lines...
end)

-- Example 3: Get git root for a file (async)
git.get_git_root("/path/to/file.lua", function(err, git_root)
  if not err then
    -- File is in a git repository
  end
end)

User Autocmd Events

CodeDiff emits User autocmd events at key lifecycle points, allowing you to customize behavior without config flags:

Event	When	Data
`CodeDiffOpen`	After diff view is fully ready	`tabpage`, `mode`
`CodeDiffClose`	Before cleanup starts	`tabpage`, `mode`
`CodeDiffFileSelect`	When a file is selected in explorer	`tabpage`, `path`, `status`

mode is one of "explorer", "standalone", or "history".

Example: Disable cursorline in diff windows

vim.api.nvim_create_autocmd("User", {
  pattern = "CodeDiffOpen",
  callback = function()
    for _, win in ipairs(vim.api.nvim_tabpage_list_wins(0)) do
      vim.wo[win].cursorline = false
    end
  end,
})

Example: Hide tabline while CodeDiff is open

vim.api.nvim_create_autocmd("User", {
  pattern = "CodeDiffOpen",
  callback = function()
    vim.g.codediff_saved_showtabline = vim.o.showtabline
    vim.o.showtabline = 0
  end,
})
vim.api.nvim_create_autocmd("User", {
  pattern = "CodeDiffClose",
  callback = function()
    if vim.g.codediff_saved_showtabline then
      vim.o.showtabline = vim.g.codediff_saved_showtabline
      vim.g.codediff_saved_showtabline = nil
    end
  end,
})

```

Architecture

Components

C Module (libvscode-diff/): Fast diff computation and render plan generation
- Myers diff algorithm
- Character-level refinement for highlighting
- Matches VSCode's rangeMapping.ts data structures
Lua FFI Layer (lua/vscode-diff/diff.lua): Bridge between C and Lua
- FFI declarations matching C structs
- Type conversions between C and Lua
Render Module (lua/vscode-diff/render/): Neovim buffer rendering
- VSCode-style highlight groups
- Virtual line insertion for alignment
- Side-by-side window management
- Git status explorer

Syntax Highlighting

The plugin handles syntax highlighting differently based on buffer type:

Working files (editable):

Behaves like normal buffers with standard highlighting
Inlay hints disabled by default (incompatible with diff highlights)
All LSP features available

Git history files (read-only):

Virtual buffers stored in memory, discarded when tab closes
TreeSitter highlighting applied automatically (if installed)
LSP not attached (most features meaningless for historical files)
Semantic token highlighting fetched via LSP request when available

Highlight Groups

The plugin defines highlight groups matching VSCode's diff colors:

CodeDiffLineInsert - Light green background for inserted lines
CodeDiffLineDelete - Light red background for deleted lines
CodeDiffCharInsert - Deep/dark green for inserted characters
CodeDiffCharDelete - Deep/dark red for deleted characters
CodeDiffFiller - Gray foreground for filler line slashes (╱╱╱)
CodeDiffLineMove - Background for moved code lines (derived from DiffChange)
CodeDiffMoveTo - Sign column and annotation color for move indicators

📸 Visual Examples (click to collapse)

Dawnfox Light - Default configuration with auto-detected brightness (char_brightness = 0.92 for light themes):

Catppuccin Mocha - Default configuration with auto-detected brightness (char_brightness = 1.4 for dark themes):

Kanagawa Lotus - Default configuration with auto-detected brightness (char_brightness = 0.92 for light themes):

Default behavior:

Uses your colorscheme's DiffAdd and DiffDelete for line-level highlights
Character-level highlights are auto-adjusted based on vim.o.background:
- Dark themes (background = "dark"): Brightness multiplied by 1.4 (40% brighter)
- Light themes (background = "light"): Brightness multiplied by 0.92 (8% darker)
This auto-detection works out-of-box for most colorschemes
You can override with explicit char_brightness value if needed

Customization examples:

-- Use hex colors directly
highlights = {
  line_insert = "#1d3042",
  line_delete = "#351d2b",
  char_brightness = 1.5,  -- Override auto-detection with explicit value
}

-- Override character colors explicitly
highlights = {
  line_insert = "DiffAdd",
  line_delete = "DiffDelete",
  char_insert = "#3fb950",
  char_delete = "#ff7b72",
}

-- Mix highlight groups and hex colors
highlights = {
  line_insert = "String",
  char_delete = "#ff0000",
}

Development

Building

make clean && make

Testing

Run all tests:

make test              # Run all tests (C + Lua integration)

Run specific test suites:

make test-c            # C unit tests only
make test-lua          # Lua integration tests only

For more details on the test structure, see tests/README.md.

Project Structure

codediff.nvim/
├── libvscode-diff/        # C diff engine
│   ├── src/               # C implementation
│   ├── include/           # C headers
│   └── tests/             # C unit tests
├── lua/
│   ├── codediff/          # Main Lua modules
│   │   ├── init.lua       # Main API
│   │   ├── config.lua     # Configuration
│   │   ├── diff.lua       # FFI interface
│   │   ├── git.lua        # Git operations
│   │   ├── commands.lua   # Command handlers
│   │   ├── installer.lua  # Binary installer
│   │   └── ui/            # UI components
│   │       ├── core.lua       # Diff rendering
│   │       ├── highlights.lua # Highlight setup
│   │       ├── view/          # View management
│   │       ├── explorer/      # Git status explorer
│   │       ├── history/       # Commit history panel
│   │       ├── lifecycle/     # Lifecycle management
│   │       └── conflict/      # Conflict resolution
│   └── vscode-diff/       # Backward compatibility shims
├── plugin/                # Plugin entry point
│   └── codediff.lua       # Auto-loaded on startup
├── tests/                 # Test suite (plenary.nvim)
├── docs/                  # Documentation and development history
├── Makefile               # Build automation
└── README.md

Roadmap

Current Status: Complete ✅

Future Enhancements

Inline diff mode (single buffer view)
Moved code detection (VSCode parity)
Fold support for large diffs

VSCode Reference

This plugin follows VSCode's diff rendering architecture:

Data structures: Based on src/vs/editor/common/diff/rangeMapping.ts
Decorations: Based on src/vs/editor/browser/widget/diffEditor/registrations.contribution.ts
Styling: Based on src/vs/editor/browser/widget/diffEditor/style.css

License

MIT

Contributing

Contributions are welcome! Please ensure:

C tests pass (make test)
Lua tests pass
Code follows existing style
Updates to README if adding features

lite-xl/lite-xl

A lightweight text editor written in Lua

Lite XL

A lightweight text editor written in Lua, adapted from lite.

Get Lite XL — Download for Windows, Linux and Mac OS.
Get plugins — Add additional functionality, adapted for Lite XL.
Get color themes — Add additional colors themes.

Please refer to our website for the user and developer documentation, including build instructions details. A quick build guide is described below.

Lite XL has support for high DPI display on Windows and Linux and, since 1.16.7 release, it supports retina displays on macOS.

Please note that Lite XL is compatible with lite for most plugins and all color themes. We provide a separate lite-xl-plugins repository for Lite XL, because in some cases some adaptations may be needed to make them work better with Lite XL. The repository with modified plugins is https://github.com/lite-xl/lite-xl-plugins.

The changes and differences between Lite XL and rxi/lite are listed in the changelog.

Overview

Lite XL is derived from lite. It is a lightweight text editor written mostly in Lua — it aims to provide something practical, pretty, small and fast easy to modify and extend, or to use without doing either.

The aim of Lite XL compared to lite is to be more user friendly, improve the quality of font rendering, and reduce CPU usage.

Customization

Additional functionality can be added through plugins which are available in the plugins repository or in the Lite XL plugins repository.

Additional color themes can be found in the colors repository. These color themes are bundled with all releases of Lite XL by default.

Quick Build Guide

To compile Lite XL yourself, you must have the following dependencies installed via your desired package manager, or manually.

Prerequisites

Meson (>=0.63)
Ninja
SDL2
PCRE2
FreeType2
Lua 5.4
A working C compiler (GCC / Clang / MSVC)

SDL2, PCRE2, FreeType2 and Lua will be downloaded by Meson if --wrap-mode=forcefallback or --wrap-mode=default is specified.

Note

MSVC is used in the CI, but MSVC-compiled binaries are not distributed officially or tested extensively for bugs.

On Linux, you may install the following dependencies for the SDL2 X11 and/or Wayland backend to work properly:

libX11-devel
libXi-devel
libXcursor-devel
libxkbcommon-devel
libXrandr-devel
wayland-devel
wayland-protocols-devel
dbus-devel
ibus-devel

The following command can be used to install the dependencies in Ubuntu:

apt-get install python3.8 python3-pip build-essential git cmake wayland-protocols libsdl2-dev
pip3 install meson ninja

Please refer to lite-xl-build-box for a working Linux build environment used to package official Lite XL releases.

On macOS, you must install bash via Brew, as the default bash version on macOS is antiquated and may not run the build script correctly.

Building

You can use scripts/build.sh to set up Lite XL and build it.

$ bash build.sh --help
# Usage: scripts/build.sh <OPTIONS>
# 
# Available options:
# 
# -b --builddir DIRNAME         Sets the name of the build directory (not path).
#                               Default: 'build-x86_64-linux'.
#    --debug                    Debug this script.
# -f --forcefallback            Force to build dependencies statically.
# -h --help                     Show this help and exit.
# -d --debug-build              Builds a debug build.
# -p --prefix PREFIX            Install directory prefix. Default: '/'.
# -B --bundle                   Create an App bundle (macOS only)
# -A --addons                   Add in addons
# -P --portable                 Create a portable binary package.
# -r --reconfigure              Tries to reuse the meson build directory, if possible.
#                               Default: Deletes the build directory and recreates it.
# -O --pgo                      Use profile guided optimizations (pgo).
#                               macOS: disabled when used with --bundle,
#                               Windows: Implicit being the only option.
#    --cross-platform PLATFORM  Cross compile for this platform.
#                               The script will find the appropriate
#                               cross file in 'resources/cross'.
#    --cross-arch ARCH          Cross compile for this architecture.
#                               The script will find the appropriate
#                               cross file in 'resources/cross'.
#    --cross-file CROSS_FILE    Cross compile with the given cross file.

Alternatively, you can use the following commands to customize the build:

meson setup --buildtype=release --prefix <prefix> build
meson compile -C build
DESTDIR="$(pwd)/lite-xl" meson install --skip-subprojects -C build

where <prefix> might be one of /, /usr or /opt, the default is /. To build a bundle application on macOS:

meson setup --buildtype=release --Dbundle=true --prefix / build
meson compile -C build
DESTDIR="$(pwd)/Lite XL.app" meson install --skip-subprojects -C build

Please note that the package is relocatable to any prefix and the option prefix affects only the place where the application is actually installed.

Installing Prebuilt

Head over to releases and download the version for your operating system.

The prebuilt releases supports the following OSes:

Windows 7 and above
Ubuntu 18.04 and above (glibc 2.27 and above)
OS X El Capitan and above (version 10.11 and above)

Some distributions may provide custom binaries for their platforms.

Windows

Lite XL comes with installers on Windows for typical installations. Alternatively, we provide ZIP archives that you can download and extract anywhere and run directly.

To make Lite XL portable (e.g. running Lite XL from a thumb drive), simply create a user folder where lite-xl.exe is located. Lite XL will load and store all your configurations and plugins in the folder.

macOS

We provide DMG files for macOS. Simply drag the program into your Applications folder.

Important Newer versions of Lite XL are signed with a self-signed certificate, so you'll have to follow these steps when running Lite XL for the first time.

Find Lite XL in Finder (do not open it in Launchpad).

Control-click Lite XL, then choose Open from the shortcut menu.

Click Open in the popup menu.

The correct steps may vary between macOS versions, so you should refer to the macOS User Guide.

On an older version of Lite XL, you will need to run these commands instead:
# clears attributes from the directory
xattr -cr /Applications/Lite\ XL.app
Otherwise, macOS will display a very misleading error saying that the application is damaged.

Linux

Unzip the file and cd into the lite-xl directory:

tar -xzf <file>
cd lite-xl

To run lite-xl without installing:

./lite-xl

To install lite-xl copy files over into appropriate directories:

rm -rf  $HOME/.local/share/lite-xl $HOME/.local/bin/lite-xl
mkdir -p $HOME/.local/bin && cp lite-xl $HOME/.local/bin/
mkdir -p $HOME/.local/share/lite-xl && cp -r data/* $HOME/.local/share/lite-xl/

Add Lite XL to PATH

To run Lite XL from the command line, you must add it to PATH.

If $HOME/.local/bin is not in PATH:

echo -e 'export PATH=$PATH:$HOME/.local/bin' >> $HOME/.bashrc

Alternatively on recent versions of GNOME and KDE Plasma, you can add $HOME/.local/bin to PATH via ~/.config/environment.d/envvars.conf:

PATH=$HOME/.local/bin:$PATH

Note Some systems might not load .bashrc when logging in. This can cause problems with launching applications from the desktop / menu.

Add Lite XL to application launchers

To get the icon to show up in app launcher, you need to create a desktop entry and put it into /usr/share/applications or ~/.local/share/applications.

Here is an example for a desktop entry in ~/.local/share/applications/com.lite_xl.LiteXL.desktop, assuming Lite XL is in PATH:

[Desktop Entry]
Type=Application
Name=Lite XL
Comment=A lightweight text editor written in Lua
Exec=lite-xl %F
Icon=lite-xl
Terminal=false
StartupWMClass=lite-xl
Categories=Development;IDE;
MimeType=text/plain;inode/directory;

To get the icon to show up in app launcher immediately, run:

xdg-desktop-menu forceupdate

Alternatively, you may log out and log in again.

Uninstall

To uninstall Lite XL, run:

rm -f $HOME/.local/bin/lite-xl
rm -rf $HOME/.local/share/icons/hicolor/scalable/apps/lite-xl.svg \
          $HOME/.local/share/applications/com.lite_xl.LiteXL.desktop \
          $HOME/.local/share/metainfo/com.lite_xl.LiteXL.appdata.xml \
          $HOME/.local/share/lite-xl

Contributing

Any additional functionality that can be added through a plugin should be done as a plugin, after which a pull request to the Lite XL plugins repository can be made.

Pull requests to improve or modify the editor itself are welcome. See CONTRIBUTING.md for more details.

Licenses

This project is free software; you can redistribute it and/or modify it under the terms of the MIT license. See LICENSE for details.

See the licenses file for details on licenses used by the required dependencies.

sindrets/diffview.nvim

Single tabpage interface for easily cycling through diffs for all modified files for any git rev.

Diffview.nvim

Single tabpage interface for easily cycling through diffs for all modified files for any git rev.

Introduction

Vim's diff mode is pretty good, but there is no convenient way to quickly bring up all modified files in a diffsplit. This plugin aims to provide a simple, unified, single tabpage interface that lets you easily review all changed files for any git rev.

Requirements

Git ≥ 2.31.0 (for Git support)
Mercurial ≥ 5.4.0 (for Mercurial support)
Neovim ≥ 0.7.0 (with LuaJIT)
nvim-web-devicons (optional) For file icons

Installation

Install the plugin with your package manager of choice.

" Plug
Plug 'sindrets/diffview.nvim'

-- Packer
use "sindrets/diffview.nvim"

Merge Tool

Opening a diff view during a merge or a rebase will list the conflicted files in their own section. When opening a conflicted file, it will open in a 3-way diff allowing you to resolve the merge conflicts with the context of the target branch's version, as well as the version from the branch which is being merged.

The 3-way diff is only the default layout for merge conflicts. There are multiple variations on this layout, a 4-way diff layout, and a single window layout available.

In addition to the normal :h copy-diffs mappings, there are default mappings provided for jumping between conflict markers, obtaining a hunk directly from any of the diff buffers, and accepting any one, all, or none of the versions of a file given by a conflict region.

For more information on the merge tool, mappings, layouts and how to configure them, see:

:h diffview-merge-tool
:h diffview-config-view.x.layout

File History

The file history view allows you to list all the commits that affected a given set of paths, and view the changes made in a diff split. This is a porcelain interface for git-log, and supports a good number of its options. Things like:

Filtering commits by grepping commit messages and commit authors.
Tracing the line evolution of a given set of line ranges for multiple files.
Only listing changes for a specific commit range, branch, or tag.
Following file changes through renames.

Get started by opening file history for:

The current branch: :DiffviewFileHistory
The current file: :DiffviewFileHistory %

For more info, see :h :DiffviewFileHistory.

Usage

`:DiffviewOpen [git rev] [options] [ -- {paths...}]`

Calling :DiffviewOpen with no args opens a new Diffview that compares against the current index. You can also provide any valid git rev to view only changes for that rev.

Examples:

:DiffviewOpen
:DiffviewOpen HEAD~2
:DiffviewOpen HEAD~4..HEAD~2
:DiffviewOpen d4a7b0d
:DiffviewOpen d4a7b0d^!
:DiffviewOpen d4a7b0d..519b30e
:DiffviewOpen origin/main...HEAD

You can also provide additional paths to narrow down what files are shown:

:DiffviewOpen HEAD~2 -- lua/diffview plugin

For information about additional [options], visit the documentation.

Additional commands for convenience:

:DiffviewClose: Close the current diffview. You can also use :tabclose.
:DiffviewToggleFiles: Toggle the file panel.
:DiffviewFocusFiles: Bring focus to the file panel.
:DiffviewRefresh: Update stats and entries in the file list of the current Diffview.

With a Diffview open and the default key bindings, you can cycle through changed files with <tab> and <s-tab> (see configuration to change the key bindings).

Staging

You can stage individual hunks by editing any buffer that represents the index (after running :DiffviewOpen with no [git-rev] the entries under "Changes" will have the index buffer on the left side, and the entries under "Staged changes" will have it on the right side). Once you write to an index buffer the index will be updated.

`:[range]DiffviewFileHistory [paths] [options]`

Opens a new file history view that lists all commits that affected the given paths. This is a porcelain interface for git-log. Both [paths] and [options] may be specified in any order, even interchangeably.

If no [paths] are given, defaults to the top-level of the working tree. The top-level will be inferred from the current buffer when possible, otherwise the cwd is used. Multiple [paths] may be provided and git pathspec is supported.

If [range] is given, the file history view will trace the line evolution of the given range in the current file (for more info, see the -L flag in the docs).

Examples:

:DiffviewFileHistory
:DiffviewFileHistory %
:DiffviewFileHistory path/to/some/file.txt
:DiffviewFileHistory path/to/some/directory
:DiffviewFileHistory include/this and/this :!but/not/this
:DiffviewFileHistory --range=origin..HEAD
:DiffviewFileHistory --range=feat/example-branch
:'<,'>DiffviewFileHistory

Important

Familiarize Yourself With `:h diff-mode`

This plugin assumes you're familiar with all the features already provided by nvim's builtin diff-mode. These features include:

Jumping between hunks (:h jumpto-diffs).
Applying the changes of a diff hunk from any of the diffed buffers (:h copy-diffs).
And more...

Read the help page for more info.

Note

Additionally check out USAGE for examples of some more specific use-cases.

Configuration

Example config with default values

-- Lua
local actions = require("diffview.actions")

require("diffview").setup({
  diff_binaries = false,    -- Show diffs for binaries
  enhanced_diff_hl = false, -- See |diffview-config-enhanced_diff_hl|
  git_cmd = { "git" },      -- The git executable followed by default args.
  hg_cmd = { "hg" },        -- The hg executable followed by default args.
  use_icons = true,         -- Requires nvim-web-devicons
  show_help_hints = true,   -- Show hints for how to open the help panel
  watch_index = true,       -- Update views and index buffers when the git index changes.
  icons = {                 -- Only applies when use_icons is true.
    folder_closed = "",
    folder_open = "",
  },
  signs = {
    fold_closed = "",
    fold_open = "",
    done = "✓",
  },
  view = {
    -- Configure the layout and behavior of different types of views.
    -- Available layouts:
    --  'diff1_plain'
    --    |'diff2_horizontal'
    --    |'diff2_vertical'
    --    |'diff3_horizontal'
    --    |'diff3_vertical'
    --    |'diff3_mixed'
    --    |'diff4_mixed'
    -- For more info, see |diffview-config-view.x.layout|.
    default = {
      -- Config for changed files, and staged files in diff views.
      layout = "diff2_horizontal",
      disable_diagnostics = false,  -- Temporarily disable diagnostics for diff buffers while in the view.
      winbar_info = false,          -- See |diffview-config-view.x.winbar_info|
    },
    merge_tool = {
      -- Config for conflicted files in diff views during a merge or rebase.
      layout = "diff3_horizontal",
      disable_diagnostics = true,   -- Temporarily disable diagnostics for diff buffers while in the view.
      winbar_info = true,           -- See |diffview-config-view.x.winbar_info|
    },
    file_history = {
      -- Config for changed files in file history views.
      layout = "diff2_horizontal",
      disable_diagnostics = false,  -- Temporarily disable diagnostics for diff buffers while in the view.
      winbar_info = false,          -- See |diffview-config-view.x.winbar_info|
    },
  },
  file_panel = {
    listing_style = "tree",             -- One of 'list' or 'tree'
    tree_options = {                    -- Only applies when listing_style is 'tree'
      flatten_dirs = true,              -- Flatten dirs that only contain one single dir
      folder_statuses = "only_folded",  -- One of 'never', 'only_folded' or 'always'.
    },
    win_config = {                      -- See |diffview-config-win_config|
      position = "left",
      width = 35,
      win_opts = {},
    },
  },
  file_history_panel = {
    log_options = {   -- See |diffview-config-log_options|
      git = {
        single_file = {
          diff_merges = "combined",
        },
        multi_file = {
          diff_merges = "first-parent",
        },
      },
      hg = {
        single_file = {},
        multi_file = {},
      },
    },
    win_config = {    -- See |diffview-config-win_config|
      position = "bottom",
      height = 16,
      win_opts = {},
    },
  },
  commit_log_panel = {
    win_config = {},  -- See |diffview-config-win_config|
  },
  default_args = {    -- Default args prepended to the arg-list for the listed commands
    DiffviewOpen = {},
    DiffviewFileHistory = {},
  },
  hooks = {},         -- See |diffview-config-hooks|
  keymaps = {
    disable_defaults = false, -- Disable the default keymaps
    view = {
      -- The `view` bindings are active in the diff buffers, only when the current
      -- tabpage is a Diffview.
      { "n", "<tab>",       actions.select_next_entry,              { desc = "Open the diff for the next file" } },
      { "n", "<s-tab>",     actions.select_prev_entry,              { desc = "Open the diff for the previous file" } },
      { "n", "[F",          actions.select_first_entry,             { desc = "Open the diff for the first file" } },
      { "n", "]F",          actions.select_last_entry,              { desc = "Open the diff for the last file" } },
      { "n", "gf",          actions.goto_file_edit,                 { desc = "Open the file in the previous tabpage" } },
      { "n", "<C-w><C-f>",  actions.goto_file_split,                { desc = "Open the file in a new split" } },
      { "n", "<C-w>gf",     actions.goto_file_tab,                  { desc = "Open the file in a new tabpage" } },
      { "n", "<leader>e",   actions.focus_files,                    { desc = "Bring focus to the file panel" } },
      { "n", "<leader>b",   actions.toggle_files,                   { desc = "Toggle the file panel." } },
      { "n", "g<C-x>",      actions.cycle_layout,                   { desc = "Cycle through available layouts." } },
      { "n", "[x",          actions.prev_conflict,                  { desc = "In the merge-tool: jump to the previous conflict" } },
      { "n", "]x",          actions.next_conflict,                  { desc = "In the merge-tool: jump to the next conflict" } },
      { "n", "<leader>co",  actions.conflict_choose("ours"),        { desc = "Choose the OURS version of a conflict" } },
      { "n", "<leader>ct",  actions.conflict_choose("theirs"),      { desc = "Choose the THEIRS version of a conflict" } },
      { "n", "<leader>cb",  actions.conflict_choose("base"),        { desc = "Choose the BASE version of a conflict" } },
      { "n", "<leader>ca",  actions.conflict_choose("all"),         { desc = "Choose all the versions of a conflict" } },
      { "n", "dx",          actions.conflict_choose("none"),        { desc = "Delete the conflict region" } },
      { "n", "<leader>cO",  actions.conflict_choose_all("ours"),    { desc = "Choose the OURS version of a conflict for the whole file" } },
      { "n", "<leader>cT",  actions.conflict_choose_all("theirs"),  { desc = "Choose the THEIRS version of a conflict for the whole file" } },
      { "n", "<leader>cB",  actions.conflict_choose_all("base"),    { desc = "Choose the BASE version of a conflict for the whole file" } },
      { "n", "<leader>cA",  actions.conflict_choose_all("all"),     { desc = "Choose all the versions of a conflict for the whole file" } },
      { "n", "dX",          actions.conflict_choose_all("none"),    { desc = "Delete the conflict region for the whole file" } },
    },
    diff1 = {
      -- Mappings in single window diff layouts
      { "n", "g?", actions.help({ "view", "diff1" }), { desc = "Open the help panel" } },
    },
    diff2 = {
      -- Mappings in 2-way diff layouts
      { "n", "g?", actions.help({ "view", "diff2" }), { desc = "Open the help panel" } },
    },
    diff3 = {
      -- Mappings in 3-way diff layouts
      { { "n", "x" }, "2do",  actions.diffget("ours"),            { desc = "Obtain the diff hunk from the OURS version of the file" } },
      { { "n", "x" }, "3do",  actions.diffget("theirs"),          { desc = "Obtain the diff hunk from the THEIRS version of the file" } },
      { "n",          "g?",   actions.help({ "view", "diff3" }),  { desc = "Open the help panel" } },
    },
    diff4 = {
      -- Mappings in 4-way diff layouts
      { { "n", "x" }, "1do",  actions.diffget("base"),            { desc = "Obtain the diff hunk from the BASE version of the file" } },
      { { "n", "x" }, "2do",  actions.diffget("ours"),            { desc = "Obtain the diff hunk from the OURS version of the file" } },
      { { "n", "x" }, "3do",  actions.diffget("theirs"),          { desc = "Obtain the diff hunk from the THEIRS version of the file" } },
      { "n",          "g?",   actions.help({ "view", "diff4" }),  { desc = "Open the help panel" } },
    },
    file_panel = {
      { "n", "j",              actions.next_entry,                     { desc = "Bring the cursor to the next file entry" } },
      { "n", "<down>",         actions.next_entry,                     { desc = "Bring the cursor to the next file entry" } },
      { "n", "k",              actions.prev_entry,                     { desc = "Bring the cursor to the previous file entry" } },
      { "n", "<up>",           actions.prev_entry,                     { desc = "Bring the cursor to the previous file entry" } },
      { "n", "<cr>",           actions.select_entry,                   { desc = "Open the diff for the selected entry" } },
      { "n", "o",              actions.select_entry,                   { desc = "Open the diff for the selected entry" } },
      { "n", "l",              actions.select_entry,                   { desc = "Open the diff for the selected entry" } },
      { "n", "<2-LeftMouse>",  actions.select_entry,                   { desc = "Open the diff for the selected entry" } },
      { "n", "-",              actions.toggle_stage_entry,             { desc = "Stage / unstage the selected entry" } },
      { "n", "s",              actions.toggle_stage_entry,             { desc = "Stage / unstage the selected entry" } },
      { "n", "S",              actions.stage_all,                      { desc = "Stage all entries" } },
      { "n", "U",              actions.unstage_all,                    { desc = "Unstage all entries" } },
      { "n", "X",              actions.restore_entry,                  { desc = "Restore entry to the state on the left side" } },
      { "n", "L",              actions.open_commit_log,                { desc = "Open the commit log panel" } },
      { "n", "zo",             actions.open_fold,                      { desc = "Expand fold" } },
      { "n", "h",              actions.close_fold,                     { desc = "Collapse fold" } },
      { "n", "zc",             actions.close_fold,                     { desc = "Collapse fold" } },
      { "n", "za",             actions.toggle_fold,                    { desc = "Toggle fold" } },
      { "n", "zR",             actions.open_all_folds,                 { desc = "Expand all folds" } },
      { "n", "zM",             actions.close_all_folds,                { desc = "Collapse all folds" } },
      { "n", "<c-b>",          actions.scroll_view(-0.25),             { desc = "Scroll the view up" } },
      { "n", "<c-f>",          actions.scroll_view(0.25),              { desc = "Scroll the view down" } },
      { "n", "<tab>",          actions.select_next_entry,              { desc = "Open the diff for the next file" } },
      { "n", "<s-tab>",        actions.select_prev_entry,              { desc = "Open the diff for the previous file" } },
      { "n", "[F",             actions.select_first_entry,             { desc = "Open the diff for the first file" } },
      { "n", "]F",             actions.select_last_entry,              { desc = "Open the diff for the last file" } },
      { "n", "gf",             actions.goto_file_edit,                 { desc = "Open the file in the previous tabpage" } },
      { "n", "<C-w><C-f>",     actions.goto_file_split,                { desc = "Open the file in a new split" } },
      { "n", "<C-w>gf",        actions.goto_file_tab,                  { desc = "Open the file in a new tabpage" } },
      { "n", "i",              actions.listing_style,                  { desc = "Toggle between 'list' and 'tree' views" } },
      { "n", "f",              actions.toggle_flatten_dirs,            { desc = "Flatten empty subdirectories in tree listing style" } },
      { "n", "R",              actions.refresh_files,                  { desc = "Update stats and entries in the file list" } },
      { "n", "<leader>e",      actions.focus_files,                    { desc = "Bring focus to the file panel" } },
      { "n", "<leader>b",      actions.toggle_files,                   { desc = "Toggle the file panel" } },
      { "n", "g<C-x>",         actions.cycle_layout,                   { desc = "Cycle available layouts" } },
      { "n", "[x",             actions.prev_conflict,                  { desc = "Go to the previous conflict" } },
      { "n", "]x",             actions.next_conflict,                  { desc = "Go to the next conflict" } },
      { "n", "g?",             actions.help("file_panel"),             { desc = "Open the help panel" } },
      { "n", "<leader>cO",     actions.conflict_choose_all("ours"),    { desc = "Choose the OURS version of a conflict for the whole file" } },
      { "n", "<leader>cT",     actions.conflict_choose_all("theirs"),  { desc = "Choose the THEIRS version of a conflict for the whole file" } },
      { "n", "<leader>cB",     actions.conflict_choose_all("base"),    { desc = "Choose the BASE version of a conflict for the whole file" } },
      { "n", "<leader>cA",     actions.conflict_choose_all("all"),     { desc = "Choose all the versions of a conflict for the whole file" } },
      { "n", "dX",             actions.conflict_choose_all("none"),    { desc = "Delete the conflict region for the whole file" } },
    },
    file_history_panel = {
      { "n", "g!",            actions.options,                     { desc = "Open the option panel" } },
      { "n", "<C-A-d>",       actions.open_in_diffview,            { desc = "Open the entry under the cursor in a diffview" } },
      { "n", "y",             actions.copy_hash,                   { desc = "Copy the commit hash of the entry under the cursor" } },
      { "n", "L",             actions.open_commit_log,             { desc = "Show commit details" } },
      { "n", "X",             actions.restore_entry,               { desc = "Restore file to the state from the selected entry" } },
      { "n", "zo",            actions.open_fold,                   { desc = "Expand fold" } },
      { "n", "zc",            actions.close_fold,                  { desc = "Collapse fold" } },
      { "n", "h",             actions.close_fold,                  { desc = "Collapse fold" } },
      { "n", "za",            actions.toggle_fold,                 { desc = "Toggle fold" } },
      { "n", "zR",            actions.open_all_folds,              { desc = "Expand all folds" } },
      { "n", "zM",            actions.close_all_folds,             { desc = "Collapse all folds" } },
      { "n", "j",             actions.next_entry,                  { desc = "Bring the cursor to the next file entry" } },
      { "n", "<down>",        actions.next_entry,                  { desc = "Bring the cursor to the next file entry" } },
      { "n", "k",             actions.prev_entry,                  { desc = "Bring the cursor to the previous file entry" } },
      { "n", "<up>",          actions.prev_entry,                  { desc = "Bring the cursor to the previous file entry" } },
      { "n", "<cr>",          actions.select_entry,                { desc = "Open the diff for the selected entry" } },
      { "n", "o",             actions.select_entry,                { desc = "Open the diff for the selected entry" } },
      { "n", "l",             actions.select_entry,                { desc = "Open the diff for the selected entry" } },
      { "n", "<2-LeftMouse>", actions.select_entry,                { desc = "Open the diff for the selected entry" } },
      { "n", "<c-b>",         actions.scroll_view(-0.25),          { desc = "Scroll the view up" } },
      { "n", "<c-f>",         actions.scroll_view(0.25),           { desc = "Scroll the view down" } },
      { "n", "<tab>",         actions.select_next_entry,           { desc = "Open the diff for the next file" } },
      { "n", "<s-tab>",       actions.select_prev_entry,           { desc = "Open the diff for the previous file" } },
      { "n", "[F",            actions.select_first_entry,          { desc = "Open the diff for the first file" } },
      { "n", "]F",            actions.select_last_entry,           { desc = "Open the diff for the last file" } },
      { "n", "gf",            actions.goto_file_edit,              { desc = "Open the file in the previous tabpage" } },
      { "n", "<C-w><C-f>",    actions.goto_file_split,             { desc = "Open the file in a new split" } },
      { "n", "<C-w>gf",       actions.goto_file_tab,               { desc = "Open the file in a new tabpage" } },
      { "n", "<leader>e",     actions.focus_files,                 { desc = "Bring focus to the file panel" } },
      { "n", "<leader>b",     actions.toggle_files,                { desc = "Toggle the file panel" } },
      { "n", "g<C-x>",        actions.cycle_layout,                { desc = "Cycle available layouts" } },
      { "n", "g?",            actions.help("file_history_panel"),  { desc = "Open the help panel" } },
    },
    option_panel = {
      { "n", "<tab>", actions.select_entry,          { desc = "Change the current option" } },
      { "n", "q",     actions.close,                 { desc = "Close the panel" } },
      { "n", "g?",    actions.help("option_panel"),  { desc = "Open the help panel" } },
    },
    help_panel = {
      { "n", "q",     actions.close,  { desc = "Close help menu" } },
      { "n", "<esc>", actions.close,  { desc = "Close help menu" } },
    },
  },
})

Hooks

The hooks table allows you to define callbacks for various events emitted from Diffview. The available hooks are documented in detail in :h diffview-config-hooks. The hook events are also available as User autocommands. See :h diffview-user-autocmds for more details.

Examples:

hooks = {
  diff_buf_read = function(bufnr)
    -- Change local options in diff buffers
    vim.opt_local.wrap = false
    vim.opt_local.list = false
    vim.opt_local.colorcolumn = { 80 }
  end,
  view_opened = function(view)
    print(
      ("A new %s was opened on tab page %d!")
      :format(view.class:name(), view.tabpage)
    )
  end,
}

Keymaps

The keymaps config is structured as a table with sub-tables for various different contexts where mappings can be declared. In these sub-tables key-value pairs are treated as the {lhs} and {rhs} of a normal mode mapping. These mappings all use the :map-arguments silent, nowait, and noremap. The implementation uses vim.keymap.set(), so the {rhs} can be either a vim command in the form of a string, or it can be a lua function:

  view = {
    -- Vim command:
    ["a"] = "<Cmd>echom 'foo'<CR>",
    -- Lua function:
    ["b"] = function() print("bar") end,
  }

For more control (i.e. mappings for other modes), you can also define index values as list-like tables containing the arguments for vim.keymap.set(). This way you can also change all the :map-arguments with the only exception being the buffer field, as this will be overridden with the target buffer number:

view = {
  -- Normal and visual mode mapping to vim command:
  { { "n", "v" }, "<leader>a", "<Cmd>echom 'foo'<CR>", { silent = true } },
  -- Visual mode mapping to lua function:
  { "v", "<leader>b", function() print("bar") end, { nowait = true } },
}

To disable any single mapping without disabling them all, set its {rhs} to false:

  view = {
    -- Disable the default normal mode mapping for `<tab>`:
    ["<tab>"] = false,
    -- Disable the default visual mode mapping for `gf`:
    { "x", "gf", false },
  }

Most of the mapped file panel actions also work from the view if they are added to the view maps (and vice versa). The exception is for actions that only really make sense specifically in the file panel, such as next_entry, prev_entry. Actions such as toggle_stage_entry and restore_entry work just fine from the view. When invoked from the view, these will target the file currently open in the view rather than the file under the cursor in the file panel.

For more details on how to set mappings for other modes, actions, and more see:

:h diffview-config-keymaps
:h diffview-actions

Restoring Files

If the right side of the diff is showing the local state of a file, you can restore the file to the state from the left side of the diff (key binding X from the file panel by default). The current state of the file is stored in the git object database, and a command is echoed that shows how to undo the change.

Tips and FAQ

Hide untracked files:
- DiffviewOpen -uno
Exclude certain paths:
- DiffviewOpen -- :!exclude/this :!and/this
Run as if git was started in a specific directory:
- DiffviewOpen -C/foo/bar/baz
Diff the index against a git rev:
- DiffviewOpen HEAD~2 --cached
- Defaults to HEAD if no rev is given.
Q: How do I get the diagonal lines in place of deleted lines in diff-mode?
- A: Change your :h 'fillchars':
  - (vimscript): set fillchars+=diff:╱
  - (Lua): vim.opt.fillchars:append { diff = "╱" }
- Note: whether or not the diagonal lines will line up nicely will depend on your terminal emulator. The terminal used in the screenshots is Kitty.
Q: How do I jump between hunks in the diff?
- A: Use [c and ]c
- :h jumpto-diffs

sphamba/smear-cursor.nvim

🌠 Neovim plugin to animate the cursor with a smear effect in all terminals

Smear cursor for Neovim

Neovim plugin to animate the cursor with a smear effect in all terminals. Inspired by Neovide's animated cursor.

This plugin is intended for terminals/GUIs that can only display text and do not have graphical capabilities (unlike Neovide, or the Kitty terminal). Also, check out the karb94/neoscroll.nvim plugin for smooth scrolling!

🚀 Demo

Demo

Some configuration examples:

Default	Faster

Smooth cursor without smear	Smooth caret

Fire hazard

📦 Installation

Note

After enabling the plugin in your configuration, you can toggle the smear cursor on and off with the :SmearCursorToggle command or with :lua require("smear_cursor").toggle().

Minimum requirements

Neovim 0.10.2

Using vim.pack

In your ~/.config/nvim/init.lua, add:

vim.pack.add({
  "https://github.com/sphamba/smear-cursor.nvim",
})

require('smear_cursor').setup({
  -- Your options
})

Using lazy.nvim

In ~/.config/nvim/lua/plugins/smear_cursor.lua, add:

return {
  "sphamba/smear-cursor.nvim",
  opts = {},
}

Using vim-plug

In your init.vim, add:

call plug#begin()
Plug 'sphamba/smear-cursor.nvim'
call plug#end()

lua require('smear_cursor').enabled = true

⚙ Configuration

Using lazy.nvim

Here are the default configuration options:

return {
  "sphamba/smear-cursor.nvim",

  opts = {
    -- Smear cursor when switching buffers or windows.
    smear_between_buffers = true,

    -- Smear cursor when moving within line or to neighbor lines.
    -- Use `min_horizontal_distance_smear` and `min_vertical_distance_smear` for finer control
    smear_between_neighbor_lines = true,

    -- Draw the smear in buffer space instead of screen space when scrolling
    scroll_buffer_space = true,

    -- Set to `true` if your font supports legacy computing symbols (block unicode symbols).
    -- Smears and particles will look a lot less blocky.
    legacy_computing_symbols_support = false,

    -- Smear cursor in insert mode.
    -- See also `vertical_bar_cursor_insert_mode` and `distance_stop_animating_vertical_bar`.
    smear_insert_mode = true,
  },
}

Refer to lua/smear_cursor/config.lua and lua/smear_cursor/color.lua for the full list of configuration options that can be set with opts.

Tip

Some terminals override the cursor color set by Neovim. If that is the case, manually put the actual cursor color in your config to get a matching smear color:

  opts = {
    -- Smear cursor color. Defaults to Cursor GUI color if not set.
    -- Set to "none" to match the text color at the target cursor position.
    -- Can be a hex color code, or a highlight group name.
    cursor_color = "#d3cdc3",
  }

Note

Fonts with legacy computing symbols support seems to be rare. One notable example is Cascadia Code. You can still use smear-cursor.nvim without such a font.

Examples

Tip

See videos at the top for visual examples.

🔥 Faster smear

As an example of further configuration, you can tune the smear dynamics to be snappier:

  opts = {                                -- Default  Range
    stiffness = 0.8,                      -- 0.6      [0, 1]
    trailing_stiffness = 0.6,             -- 0.45     [0, 1]
    stiffness_insert_mode = 0.7,          -- 0.5      [0, 1]
    trailing_stiffness_insert_mode = 0.7, -- 0.5      [0, 1]
    damping = 0.95,                       -- 0.85     [0, 1]
    damping_insert_mode = 0.95,           -- 0.9      [0, 1]
    distance_stop_animating = 0.5,        -- 0.1      > 0
  },

If you notice a low framerate, you can try lowering the time interval between draws (default is 17ms):

  opts = {
    time_interval = 7, -- milliseconds
  },

You can also change the "bounciness" of the smear by adjusting the damping and damping_insert_mode parameters (default to 0.85 and 0.9 respectively). Decreasing them (e.g. to 0.65) will make the smear appear more elastic (overshooting target position).

🔥 FIRE HAZARD 🔥

Feel free to experiment with all the configuration options, but be aware that some combinations may cause your cursor to flicker or even catch fire. That can happen with the following settings:

 opts = {
   cursor_color = "#ff4000",
   particles_enabled = true,
   stiffness = 0.5,
   trailing_stiffness = 0.2,
   trailing_exponent = 5,
   damping = 0.6,
   gradient_exponent = 0,
   gamma = 1,
   never_draw_over_target = true, -- if you want to actually see under the cursor
   hide_target_hack = true,       -- same
   particle_spread = 1,
   particles_per_second = 500,
   particles_per_length = 50,
   particle_max_lifetime = 800,
   particle_max_initial_velocity = 20,
   particle_velocity_from_cursor = 0.5,
   particle_damping = 0.15,
   particle_gravity = -50,
   min_distance_emit_particles = 0,
}

█ Smooth cursor without smear

If you wish to only have a smoother cursor that keeps its rectangular shape (without the trail), you can set the following options:

  opts = {
    stiffness = 0.5,
    trailing_stiffness = 0.5,
    matrix_pixel_threshold = 0.5,
  },

🌌 Transparent background

Drawing the smear over a transparent background works better when using a font that supports legacy computing symbols, therefore setting the following option:

  opts = {
    legacy_computing_symbols_support = true,
  },

If your font does not support legacy computing symbols, there will be a shadow under the smear. You may set a color for this shadow to be less noticeable:

  opts = {
    transparent_bg_fallback_color = "#303030",
  },

🔲 No GUI colors

If you are not using termguicolors, you need to manually set a color gradient for the smear (it can be a single color):

  opts = {
    cterm_cursor_colors = { 240, 245, 250, 255 },
    cterm_bg = 235,
  }

If you are not using guicursor, and you notice the cursor getting duplicated (smear visible at the same time as the real cursor), try setting

  opts = {
    hide_target_hack = true,
    never_draw_over_target = true,
  }

Using `init.vim`

You can set the configuration variables in your init.vim file like this:

lua require('smear_cursor').setup({
    \cursor_color = '#d3cdc3',
\})

🤕 Known issues

There is a shadow around the smear (text become invisible). This is inherent to the way the smear is rendered, as Neovim is not able to render superimposed characters. The shadow is less noticeable when the smear is moving faster (see configuration options).
Likely not compatible with other plugins that modify the cursor.

👨‍💻 Contributing

Please feel free to open an issue or a pull request if you have any suggestions or improvements! This project uses pre-commit hooks to ensure code quality (with StyLua) and meaningful commit messages (following Conventional Commits)

Requirements

Neovim >= 0.10.2
Make
pre-commit (pip install pre-commit)

Setup

Clone the repository
Run make install to install the pre-commit hooks

Wansmer/treesj

Neovim plugin for splitting/joining blocks of code

TreeSJ

Neovim plugin for splitting/joining blocks of code like arrays, hashes, statements, objects, dictionaries, etc.

Written in Lua, using Tree-Sitter.

Inspired by and partly repeats the functionality of splitjoin.vim.

https://github.com/Wansmer/treesj/assets/46977173/4277455b-81fd-4e99-9af7-43c77dbf542b

Features

Can be called from anywhere in the block: No need to move cursor to specified place to split/join block of code;
Make cursor sticky: The cursor follows the text on which it was called;
Autodetect mode: Toggle-mode present. Split or join blocks by same key mapping;
Do it recursively: Expand or collapse all nested nodes? Yes, you can;
Recognize nested languages: Filetype doesn't matter, detect language with treesitter;
Repeat formatting with dot: . support for each action.
Smart: Different behavior depending on the context.

Requirements

Neovim 0.9+
nvim-treesitter (optional: if you install parsers with nvim-treesitter)

Installation

With lazy.nvim:

return {
  'Wansmer/treesj',
  keys = { '<space>m', '<space>j', '<space>s' },
  dependencies = { 'nvim-treesitter/nvim-treesitter' }, -- if you install parsers with `nvim-treesitter`
  config = function()
    require('treesj').setup({--[[ your config ]]})
  end,
}

With packer.nvim:

use({
  'Wansmer/treesj',
  requires = { 'nvim-treesitter/nvim-treesitter' }, -- if you install parsers with `nvim-treesitter`
  config = function()
    require('treesj').setup({--[[ your config ]]})
  end,
})

Settings

Default configuration:

local tsj = require('treesj')

local langs = {--[[ configuration for languages ]]}

tsj.setup({
  ---@type boolean Use default keymaps (<space>m - toggle, <space>j - join, <space>s - split)
  use_default_keymaps = true,
  ---@type boolean Node with syntax error will not be formatted
  check_syntax_error = true,
  ---If line after join will be longer than max value,
  ---@type number If line after join will be longer than max value, node will not be formatted
  max_join_length = 120,
  ---Cursor behavior:
  ---hold - cursor follows the node/place on which it was called
  ---start - cursor jumps to the first symbol of the node being formatted
  ---end - cursor jumps to the last symbol of the node being formatted
  ---@type 'hold'|'start'|'end'
  cursor_behavior = 'hold',
  ---@type boolean Notify about possible problems or not
  notify = true,
  ---@type boolean Use `dot` for repeat action
  dot_repeat = true,
  ---@type nil|function Callback for treesj error handler. func (err_text, level, ...other_text)
  on_error = nil,
  ---@type table Presets for languages
  -- langs = {}, -- See the default presets in lua/treesj/langs
})

Commands

TreeSJ provide user commands:

:TSJToggle - toggle node under cursor (split if one-line and join if multiline);
:TSJSplit - split node under cursor;
:TSJJoin - join node under cursor;

Similar with lua:

:lua require('treesj').toggle()
:lua require('treesj').split()
:lua require('treesj').join()

In the lua version, you can optionally pass a preset that will overwrite the default preset values. It should contain split or join keys. Key both will be ignored.

E.g.:

-- For default preset
vim.keymap.set('n', '<leader>m', require('treesj').toggle)
-- For extending default preset with `recursive = true`
vim.keymap.set('n', '<leader>M', function()
    require('treesj').toggle({ split = { recursive = true } })
end)

How plugin works

When you run the plugin, TreeSJ detects the node under the cursor, recognizes the language, and looks for it in the presets. If the current node is not configured, TreeSJ checks the parent node, and so on, until a configured node is found.

Presets for node can be two types:

With preset for self - if this type is found, the node will be formatted;
With referens for nested nodes or fields - in this case, search will be continued among this node descendants;

Example:

"|" - meaning cursor

// with preset for self
const arr = [ 1, |2, 3 ];
                 |
    first node is 'number' - not configured,
    parent node is 'array' - configured and will be split

// with referens
cons|t arr = [ 1, 2, 3 ];
    |
  first node is 'variable_declarator' - not configured,
  parent node is 'lexical_declaration' - configured and has reference
  { target_nodes = { 'array', 'object' } },
  first configured nested node is 'array' and array will be splitted

Configuration

Languages

By default, TreeSJ has presets for these languages:

Javascript;
Typescript;
Tsx;
Jsx;
Lua;
CSS;
SCSS;
HTML;
Pug;
Vue;
Svelte;
JSON;
JSONC;
JSON5;
Toml;
Yaml;
Perl;
PHP (both php and php_only);
Ruby;
Python;
Starlark;
Go;
Java;
Rust;
R;
C/C++;
Nix;
Kotlin;
Bash;
Zsh;
SQL;
Dart;
Elixir;
Haskell;
Zig;
Julia;
Terraform;
Typst;

For adding your favorite language, add it to langs sections in your configuration. Also, see how to implement fallback to splitjoin.vim.

It is also possible to configure fallback for any node (see Advanced node).

To find out what nodes are called in your language, analyze your code with nvim-treesitter/playground or look in the source code of the parsers.

Example:

local langs = {
  javascript = {
    array = {--[[ preset ]]},
    object = {--[[ preset ]]}
    ['function'] = { target_nodes = {--[[ targets ]]}}
  },
}

If you have completely configured your language, and it works as well as you expected, feel free to open PR and share it. (Please, read manual before PR)

Basic node

Default preset for node:

local node_type = {
  -- `both` will be merged with both presets from `split` and `join` modes tables.
  -- If you need different values for different modes, they can be overridden
  -- in mode tables unless otherwise noted.
  both = {
    ---If a node contains descendants with a type from the list, it will not be formatted
    ---@type string[]
    no_format_with = { 'comment' },
    ---Separator for arrays, objects, hash e.c.t. (usually ',')
    ---@type string
    separator = '',
    ---Set last separator or not
    ---@type boolean
    last_separator = false,
    ---If true, empty brackets, empty tags, or node which only contains nodes from 'omit' no will handling
    ---@type boolean
    format_empty_node = true,
    ---All nested configured nodes will process according to their presets
    ---@type boolean
    recursive = true,
    ---Type of configured node that must be ignored
    ---@type string[]
    recursive_ignore = {},

    --[[ Working with the options below is explained in detail in `advanced node configuration` section. ]]
    ---Set `false` if node should't be splitted or joined.
    ---@type boolean|function For function: function(tsnode: TSNode): boolean
    enable = true,
    ---@type function|nil function(tsj: TreeSJ): void
    format_tree = nil,
    ---@type function|nil function(lines: string[], tsn?: TSNode): string[]
    format_resulted_lines = nil,
    ---Passes control to an external script and terminates treesj execution.
    ---@type function|nil function(node: TSNode): void
    fallback = nil,

    --[[ The options below should be the same for both modes. ]]
    ---The text of the node will be merged with the previous one, without wrapping to a new line
    ---@type table List-like table with types 'string' (type of node) or 'function' (function(child: TreeSJ): boolean).
    omit = {},
    ---Non-bracket nodes (e.g., with 'then|()' ... 'end' instead of { ... }|< ... >|[ ... ])
    ---If value is table, should be contains follow keys: { left = 'text', right = 'text' }. Empty string uses by default
    ---@type boolean|table
    non_bracket_node = false,
    ---If you need to process only nodes in the range from / to.
    ---If `shrink_node` is present, `non_bracket_node` will be ignored
    ---Learn more in advanced node configuration
    ---@type table|nil
    shrink_node = nil,
    -- shrink_node = { from = string, to = string },
  },
  -- Use only for join. If contains field from 'both',
  -- field here have higher priority
  join = {
    ---Adding space in framing brackets or last/end element
    ---@type boolean
    space_in_brackets = false,
    ---Insert space between nodes or not
    ---@type boolean
    space_separator = true,
    ---Adds instruction separator like ';' in statement block.
    ---It's not the same as `separator`: `separator` is a separate node, `force_insert` is a last symbol of code instruction.
    ---@type string
    force_insert = '',
    ---The `force_insert` symbol will be omitted if the type of node contains in this list
    -- (e.g. function_declaration inside statement_block in JS no require instruction separator (';'))
    ---@type table List-like table with types 'string' (type of node) or 'function' (function(child: TreeSJ): boolean).
    no_insert_if = {},
  },
  -- Use only for split. If contains field from 'both',
  -- field here have higher priority
  split = {
    ---All nested configured nodes will process according to their presets
    ---@type boolean
    recursive = false,
    ---Which indent must be on the last line of the formatted node.
    --- 'normal' – indent equals of the indent from first line;
    --- 'inner' – indent, like all inner nodes (indent of start line of node + vim.fn.shiftwidth()).
    ---@type 'normal'|'inner'
    last_indent = 'normal',
    ---Which indent must be on the last line of the formatted node.
    --- 'normal' – indent equals of the indent from first line;
    --- 'inner' – indent, like all inner nodes (indent of start line of node + vim.fn.shiftwidth()).
    ---@type 'normal'|'inner'
    inner_indent = 'inner',
  },
  ---If 'true', node will be completely removed from langs preset
  ---@type boolean
  disable = false,
  ---TreeSJ will search child from list into this node and redirect to found child
  ---If list not empty, another fields (split, join) will be ignored
  ---@type string[]|table See `advanced node configuration`
  target_nodes = {},
}

All nodes in every language have similar characteristics. TreeSJ provide default presets for common nodes:

set_default_preset(override) - default.

set_preset_for_list(override) - list-like nodes.

set_preset_for_dict(override) - dict-like nodes.

set_preset_for_statement(override) - statement-like nodes.

set_preset_for_args(override) - arguments-like nodes.

set_preset_for_non_bracket(override) - non-bracket nodes;

Takes a table with the settings to be overwritten as an argument.

Usage example:

local lang_utils = require('treesj.langs.utils')

local langs = {
  javascript = {
    object = lang_utils.set_preset_for_dict(),
    array = lang_utils.set_preset_for_list(),
    formal_parameters = lang_utils.set_preset_for_args(),
    arguments = lang_utils.set_preset_for_args(),
    statement_block = lang_utils.set_preset_for_statement({
      join = {
        no_insert_if = {
          'function_declaration',
          'try_statement',
          'if_statement',
        },
      },
    }),
  },
  lua = {
    table_constructor = lang_utils.set_preset_for_dict(),
    arguments = lang_utils.set_preset_for_args(),
    parameters = lang_utils.set_preset_for_args(),
  },
}

Also, you can use whole preset for language if your language has the same types of nodes:

For example, css and scss have the same structure, and you can use already configured preset

local tsj_utils = require('treesj.langs.utils')
local css = require('treesj.langs.css')

local langs = {
  scss = tsj_utils.merge_preset(css, {--[[
    Here you can override existing nodes
    or add language-specific nodes
]]})
}

Advanced node

Although most nodes have similar parameters and can be configured declarative, sometimes you need to change the values, text, or order of children on the fly.

To do this, some options accept functions as a value, which are passed instances of TSNode, TreeSJ, or an array of rows to insert.

Option `enable`

The enable option can be a boolean value or a function. The function takes the found TSNode node as arguments and should return a boolean value.

Example of usage

The problem:

// from 'import_spec_list'
import (
    "123"
)

// to 'import_spec' and back
import "123"

// but disable 'import_spec_list' when two or more 'import_spec' inside and
// disable 'import_spec' when it already inside 'import_spec_list'
import (
    "123"
    "321"
)

This can be implemented with:

local go = {
  import_spec = lang_utils.set_preset_for_args({
    both = {
      -- If the parent is a 'import_spec_list', then skip this node and
      -- look for a suitable one for formatting further
      enable = function(tsn)
        return tsn:parent():type() ~= 'import_spec_list'
      end,
    },
    split = {
      -- If the parent was something else, then wrap the import in parentheses,
      -- which actually converts the 'import_spec' into the 'import_spec_list'
      format_tree = function(tsj)
        tsj:wrap({ left = '(', right = ')' })
      end,
    },
  }),
  import_spec_list = lang_utils.set_preset_for_args({
    join = {
      enable = function(tsn)
        -- If the node contains more than one named child node, then disable
        return tsn:named_child_count() < 2
      end,
      format_tree = function(tsj)
        -- If there was only one named element, then remove the brackets
        tsj:remove_child({ '(', ')' })
      end,
    },
  }),
}

Option `fallback`

The fallback option passes control to a third-party script that can be called within the function. When this option is used, treesj only searches for the required node, but does not process it.

A found TSNode instance is passed to the function, which can be handled independently. For example, you can get the region of its location, check its siblings, etc.

Example of usage

The problem:

This action is difficult to implement with treesj, so you can pass control to splitjoin.vim if the found node is a class or module.

Note that in the above example, `splitjoin.vim' requires the cursor to be on the name of a class or module. In some cases, you may need to keep track of the position of the cursor from which the handler is called.

# RESULT OF JOIN
class Foo::Bar::Baz < Quux
  def initialize
    # foo
  end
end

# RESULT OF SPLIT
module Foo
  module Bar
    class Baz < Quux
      def initialize
        # foo
      end
    end
  end
end

This can be implemented with:

ruby = {
  module = {
    both = {
      no_format_with = {}, -- Need to avoid 'no format with comment'
      fallback = function(_)
        vim.cmd('SplitjoinJoin')
      end,
    },
  },
  class = {
    both = {
      no_format_with = {},
      fallback = function(_)
        vim.cmd('SplitjoinSplit')
      end,
    },
  },
},

Option `no_insert_if`

The preset[join].no_insert_if option takes an array with node types or functions. The function takes a TreeSJ as a parameter (each child of the root node in turn) and should return a boolean if that child matches the condition.

The utilities have helper functions that you will need most often:

lang_utils.helpers.if_penultimate

lang_utils.helpers.if_second

lang_utils.helpers.by_index(index)

lang_utils.helpers.has_parent(parent_type)

lang_utils.helpers.match(pattern)

lang_utils.helpers.contains(tsn_types)

Example of usage

The problem:

// Kotlin's 'statements' should be separated with ';' after each child
// when it joins, but for the last named child it is not necessary,
// and we want to skip it

// from
call_expression("arg1") {
  call1(1, 2)
  call2(1, 2)
}

// to                                             | here no ';', great
call_expression("arg1") { call1(1, 2); call2(1, 2) }

This can be implemented with:

local lang_utils = require('treesj.langs.utils')

local kotlin = {
  statements = lang_utils.set_preset_for_non_bracket({
    join = {
      force_insert = ';',
      no_insert_if = {
        lang_utils.no_insert.if_penultimate,
      },
    },
  }),
}

Option `omit`

The preset[both]omit option accepts a list of node types or functions. If at the time the tree is built, the type of the child matches one of the listed ones, then this child remains unchanged. (does not wrap to a new line in case of a split, or its position and spaces do not change in the case of a join).

When some value of list is function the principle of operation is the same as that of no_insert_if.

Option `non_bracket_node`

Some languages have nodes that can be split and joined, but they don't have brackets or other framing elements.

In this case, it is necessary not only to simulate the framing nodes, but also to calculate a new range for inserting rows.

preset[both].non_bracket_node can be a boolean value (in which case wrapping node imitators are created with an empty value) or take a table that specifies what text should wrap the actual base node.

E.g., table value: { left = 'text', right = 'text' }

Example of usage

The problem:

-- `block` in Lua does not have parentheses, but when it joins,
-- it must jump up a line and pull an `end` node that is not part of it.
-- To do this, you need to create imitators of framing nodes one line above
-- and one line below
               | -- imitator left-side bracket
function test()|
  | -- real start of `block`
  |print(123)
  return 123| -- real end of `block`
| -- imitator right-side bracket
|end

-- from
function test()
  print(123)
  return 123
end

-- to and back
function test() print(123) return 123 end

This can be implemented with:

local lang_utils = require('treesj.langs.utils')

local lua = {
  block = {
    both = {
      non_bracket_node = true,
      -- non_bracket_node = { left = '', right = '' }, - it is similar
    },
    join = {
      space_in_brackets = true,
    },
  },
}

Option `shrink_node`

The shrink_node option does not process or modify text outside the specified child types in from/to. This is needed when the node does not have a container, but can be split or join. For better understanding, see example of usage.

Example of usage

The problem:

In the Kotlin language, the function_declaration node has parameters in brackets, but they are not packaged in a separate container and go at the same level as the other children of the function_declaration.

The difficulty is that the last element in function_declaration is function_body, which must remain unchanged and can be multi-line.

| - start of `function_declaration`
|        | - from             | - to
|        |                    | | - `function_body` must remain unchanged
|fun test(a: String, b: String) {
         | - start insert range
                              | - end insert range
         Everything outside the insertion range will remain unchanged,
         even though it is part of the node
  val var1 = 1
  val var2 = 2
}|
 | - end of `function_declaration`

// from
fun test(a: String, b: String) {
  val var1 = 1
  val var2 = 2
}
// to
fun test(
  a: String,
  b: String
) {
  val var1 = 1
  val var2 = 2
}

This can be implemented with:

{
  function_declaration = lang_utils.set_preset_for_args({
    both = {
      non_bracket_node = true,
      shrink_node = { from = '(', to = ')' },
    },
  }),
}

Option `target_nodes`

In most cases, target_nodes is a list of node types to redirect the search for the configured node deeper. But in reality it is treated like a dictionary:

-- these values are equivalent
target_nodes = { 'block', 'statement' }
target_nodes = { ['block'] = 'block', ['statement'] = 'statement' }

The key must be a node type or a field name. The value is the name of any configured node whose preset is to be used.

If the field name is specified in the keys, then it has the highest priority over node types.

This also means that you can redirect found fields or nodes for processing with other (including custom) presets.

{
  block = lang_utils.set_preset_for_statement(),
  my_custom_preset_for_block_inside_fun_dec = {--[[ another preset ]]}
  function_declaration = {
      target_nodes = { ['block'] = 'my_custom_preset_for_block_inside_fun_dec' }
  }
}

Example of usage

The problem:

match x {
    //   | - it is a field `value` and now it `integer_literal`
    _ => 12
    //   `integer_literal` is not configured and can't be configured
    //   but you can transform this field into a `block` node
}

match x {
    _ => {
        12
    }
}

This can be implemented with:

local rust = {
  match_arm = {
    target_nodes = { 'value' },
  },
  value = lang_utils.set_preset_for_statement({
    split = {
      format_tree = function(tsj)
        if tsj:type() ~= 'block' then
          tsj:wrap({ left = '{', right = '}' })
        end
      end,
    },
    join = {
      no_insert_if = { lang_utils.helpers.if_penultimate },
      format_tree = function(tsj)
        local node = tsj:tsnode()
        local parents = { 'match_arm', 'closure_expression' }
        local has_parent = vim.tbl_contains(parents, node:parent():type())
        if has_parent and node:named_child_count() == 1 then
          tsj:remove_child({ '{', '}' })
        end
      end,
    },
  }),
}

Option `format_tree`

format_tree is a function that takes a TreeSJ root node. In this function, you can work with the context and add or remove elements.

Example of usage

The problem:

Python's import_from_statement does not have a container for a list of imported modules.

Here you need to add parentheses to the middle and end of TreeSJ when splitting and remove these parentheses when joining.

# from
from re import search, match,sub

# to this and back
from re import (
    search,
    match,
    sub,
)

This can be implemented with:

local python = {
  import_from_statement = lang_utils.set_preset_for_args({
    both = {
      -- There is no need to wrap the second element, the 'import' node,
      -- and the first parenthesis, which does not already exist.
      omit = { lang_utils.omit.if_second, 'import', ' (' },
    },
    split = {
      last_separator = true,
      format_tree = function(tsj)
        -- If there are no brackets, then create them
        if not tsj:has_children({ '(', ')' }) then
          tsj:create_child({ text = ' (' }, 4)
          tsj:create_child({ text = ')' }, #tsj:children() + 1)
          -- Since the elements have moved, you need to add the penultimate
          -- separator manually
          local penult = tsj:child(-2)
          penult:update_text(penult:text() .. ',')
        end
      end,
    },
    join = {
      format_tree = function(tsj)
        -- Remove brackets
        tsj:remove_child({ '(', ')' })
      end,
    },
  }),
}

Option `format_resulted_lines`

The format_resulted_lines function takes as an argument an array of strings that will replace the content of the base node. The second optional argument is the node that was processed. Useful if you want to format terms based on some values, such as a range.

The function should return an array of strings that may have been modified.

If the mode is "join", then after executing this function, these strings will be concatenated.

E.g.:

-- base node
local dict = { one = 'one', two = 'two' }

-- array of string for replacement is { "{", "    one = 'one',", "    two = 'two',", "}" }

-- base node after format
local dict = {
    one = 'one',
    two = 'two',
}

Example of usage

The problem:

Python's import_from_statement does not have a container for a list of imported modules.

Here you need to add parentheses to the middle and end of TreeSJ when splitting and remove these parentheses when joining.

# from
if cond
    do_that('cond')
else
    do_this('not nond')
end

# to this and back
cond ? do_that('cond') : do_this('not nond')

This can be implemented with:

local ruby = {
  conditional = lang_utils.set_default_preset({
    join = { enable = false },
    split = {
      omit = { lang_utils.omit.if_second },
      format_tree = function(tsj)
        local children = tsj:children()
        table.insert(children, tsj:create_child({ text = 'end', type = 'end' }))
        tsj:child('?'):update_text('if ')
        tsj:child(':'):update_text('else')
        local first, second = tsj:child(1), tsj:child(2)
        children[1] = second
        children[2] = first
        tsj:update_children(children)
      end,
      format_resulted_lines = function(lines)
        return vim.tbl_map(function(line)
          -- Need to remove one indent on `else` element
          if line:match('%s.else$') then
            local rgx = '^' .. (' '):rep(vim.fn.shiftwidth())
            return line:gsub(rgx, '')
          else
            return line
          end
        end, lines)
      end,
    },
  }),
}

TreeSJ instance

After the node for formatting is found, an instance of the TreeSJ class is created. Each of its children and descendants is also an instance of this class. The methods of this class can be used to change formatting behavior on the fly (see advanced node configuration).

TreeSJ Lifecycle

Checking the found Node: There is a check that there is no syntax error in the node, there are no descendants with types from preset[mode].no_format_with and preset[mode].enable is true.
Creating root TreeSJ: A node for formatting has been found and checked, and an instance of TreeSJ is created based on it.
Build tree: It iterates all the children of the base node and creates the TreeSJ children. If the preset[mode].recursive is true, then a check is made to see if the child or its children are configured, if so, a tree is built for it and its children.
Remove or insert last separator: if a separator is specified in the preset.
Run preset[mode].format_tree: custom function from preset.
Mode-based preparation: spacing or indenting, adding a preset.join.force_insert, forming a list of strings to replace the base node content.
Run preset[mode].format_resulted_lines: custom function from preset.

Methods

Show/Hide methods...

has_children

Checks if the specified types of children exist among the list of children. If types are omitted, checks that there is at least one child.

---@param types? string[]
---@return boolean
function TreeSJ:has_children(types)

iter_children

Iterate all TreeSJ children. Use: ... for child, index in tsj:iter_children() do ...

---@return function, table
function TreeSJ:iter_children()

children

Get the children list of the current TreeSJ. Returns all children if types are omitted, otherwise returns all children of the listed types.

---@param types? string[] List-like table with child's types for filtering
---@return TreeSJ[]
function TreeSJ:children(types)

root

Get root TreeSJ node of current TreeSJ

---@return TreeSJ TreeSJ instance
function TreeSJ:root()

parent

Get parent TreeSJ

---@return TreeSJ|nil
function TreeSJ:parent()

child

Get the child of the current node, using its type (tsj:type()) or index.

The index can be a negative value, which means to search from the end of the list.
If a type is passed, the first element found will be returned. To get an array of similar elements, use TreeSJ:children(types).

---@param type_or_index number|string Type of TreeSJ child or it index in children list
---@return TreeSJ|nil
function TreeSJ:child(type_or_index)

create_child

Creating a new TreeSJ instance as a child of current TreeSJ.

data: {text=string, type=string|nil, copy_from=TreeSJ|nil} The "copy_from" field is used if a node needs to be duplicated and expects TreeSJ. If a TreeSJ instance is passed to it, then the "text" and "type" fields will be ignored.
index: If index present, puts it in children list and returned this child, if not – returned child, but not puts it in children list. Index can be a negative value, meaning insert from the end. If an index is specified that is outside the list of children, then nil will be returned.

---@param data table { text = string, type? = string }. If `type` not present, uses value of `text`
---@param index? integer Index where the child should be inserted.
---@return TreeSJ|nil
function TreeSJ:create_child(data, index)

update_children

Updating children list of current TreeSJ

---@param children TreeSJ[]
function TreeSJ:update_children(children)

This function must be called every time you update the list of children from outside, for example:

-- When a function should be called
local children = tsj:children()
local child = tsj:create_child({ text = 'end' })
table.insert(children, child)
tsj:update_children(children) -- important

-- Here it is not necessary
tsj:create_child({ text = 'end' }, #tsj:children() + 1)

remove_child

Removes children by the passed types or index.

---@param types_or_index string|string[]|integer Type, types, or index of child to remove
function TreeSJ:remove_child(types_or_index)

wrap

Creates the first and last elements in the list of children of the current TreeSJ.

If the wrap mode is passed (the default), then a new list of children is created with one element as itself, and the wrapping elements are added to it.
If the inline mode is passed, then the real list of children of the current TreeSJ is used to add framing elements.

---@param data table { left = string, right = string }
---@param mode? 'wrap'|'inline' 'wrap' by default
function TreeSJ:wrap(data, mode)

swap_children

Helps to swap elements by their indexes

---@param index1 integer
---@param index2 integer
function TreeSJ:swap_children(index1, index2)

tsnode

Get TSNode or TSNode imitator of current TreeSJ. If you plan to use tsnode methods in the future, you first need to check that the returned value is not an imitator.

---@return TSNode|table TSNode or TSNode imitator
function TreeSJ:tsnode()

Get left side TreeSJ

---@return TreeSJ|nil
function TreeSJ:prev()

Get right side TreeSJ

---@return TreeSJ|nil
function TreeSJ:next()

type

Get node type of current TreeSJ.

---@return string
function TreeSJ:type()

text

Get text of current TreeSJ. At the time of the execution of the format_tree function, the text will always be returned, not the table.

---@return string|table
function TreeSJ:text()

update_text

Updating text of current TreeSJ. If the mode "split" and "recursively" is active, then it can be an array. In such a case, you need to update the text in its children directly.

---@param new_text string|string[]
function TreeSJ:update_text(new_text)

When working in recursive mode, you need to check that the nodes in which you want to change the text do not have children for recursive processing. In this case, the text will be glued from the children of the node, and you need to change the text in them.

E.g.:

{
  format_tree = function(tsj)
    if tsj:type() ~= 'statement_block' then
      -- ...
      local body = tsj:child(2)
      if body:will_be_formatted() then
        local set_return
        if body:has_preset('split') then
          set_return = body:child(1)
        else
          set_return = body:child(1):child(1)
        end
        set_return:update_text('return ' .. set_return:text())
      else
        body:update_text('return ' .. body:text())
      end
      -- ...
    end
  end,
}

will_be_formatted

Returns true if the current TreeSJ will be formatted. The conditions are met: recursion is active, the current element has a preset, or among its descendants there are nodes that will be processed.

---@return boolean
function TreeSJ:will_be_formatted()

is_ignore

Checks if the current TreeSJ child must be ignored while recursive formatting.

---@return boolean
function TreeSJ:is_ignore()

has_to_format

Checks if the TreeSJ contains children that need to be formatted

---@return boolean
function TreeSJ:has_to_format()

is_first

Checks if the current node is first among sibling

---@return boolean
function TreeSJ:is_first()

is_last

Checks if the current node is last among sibling

---@return boolean
function TreeSJ:is_last()

is_framing

Checks if the current node is first or is last among sibling

---@return boolean
function TreeSJ:is_framing()

is_omit

Checks if the text of current TreeSJ's type contains at preset[mode].omit

---@return boolean
function TreeSJ:is_omit()

is_imitator

Checks if the current TreeSJ is node-imitator

---@return boolean
function TreeSJ:is_imitator()

preset

Get preset for current TreeSJ

---@param mode? 'split'|'join' Current mode (split|join)
---@return table|nil
function TreeSJ:preset(mode)

parent_preset

Get the preset of the TreeSJ parent

---@param mode? 'split'|'join' Current mode (split|join)
---@return table|nil
function TreeSJ:parent_preset(mode)

update_preset

Updates the presets for the current TreeSJ.

---@param new_preset table
---@param mode? 'split'|'join'
function TreeSJ:update_preset(new_preset, mode)

folke/tokyonight.nvim

🏙 A clean, dark Neovim theme written in Lua, with support for lsp, treesitter and lots of plugins. Includes additional themes for Kitty, Alacritty, iTerm and Fish.

🏙 Tokyo Night

A dark and light Neovim theme written in Lua ported from the Visual Studio Code TokyoNight theme. Includes extra themes for Kitty, Alacritty, iTerm and Fish.

Moon	Storm

Night	Day

✨ Features

Supports the latest Neovim 0.9.0 features.
Terminal colors.
Supports all major plugins.
Provides TokyoNight extras for numerous other applications.

🎨 Supported Plugins

Plugin	Source
aerial.nvim	`aerial`
ale	`ale`
alpha-nvim	`alpha`
barbar.nvim	`barbar`
blink.cmp	`blink`
bufferline.nvim	`bufferline`
nvim-cmp	`cmp`
codeium.nvim	`codeium`
copilot.lua	`copilot`
nvim-dap	`dap`
dashboard-nvim	`dashboard`
flash.nvim	`flash`
fzf-lua	`fzf`
vim-gitgutter	`gitgutter`
gitsigns.nvim	`gitsigns`
glyph-palette.vim	`glyph-palette`
grug-far.nvim	`grug-far`
headlines.nvim	`headlines`
hop.nvim	`hop`
vim-illuminate	`illuminate`
indent-blankline.nvim	`indent-blankline`
indentmini.nvim	`indentmini`
lazy.nvim	`lazy`
leap.nvim	`leap`
lspsaga.nvim	`lspsaga`
mini.animate	`mini_animate`
mini.clue	`mini_clue`
mini.completion	`mini_completion`
mini.cursorword	`mini_cursorword`
mini.deps	`mini_deps`
mini.diff	`mini_diff`
mini.files	`mini_files`
mini.hipatterns	`mini_hipatterns`
mini.icons	`mini_icons`
mini.indentscope	`mini_indentscope`
mini.jump	`mini_jump`
mini.map	`mini_map`
mini.notify	`mini_notify`
mini.operators	`mini_operators`
mini.pick	`mini_pick`
mini.starter	`mini_starter`
mini.statusline	`mini_statusline`
mini.surround	`mini_surround`
mini.tabline	`mini_tabline`
mini.test	`mini_test`
mini.trailspace	`mini_trailspace`
nvim-navic	`navic`
neo-tree.nvim	`neo-tree`
neogit	`neogit`
neotest	`neotest`
noice.nvim	`noice`
nvim-notify	`notify`
nvim-tree.lua	`nvim-tree`
octo.nvim	`octo`
rainbow-delimiters.nvim	`rainbow`
render-markdown.nvim	`render-markdown`
nvim-scrollbar	`scrollbar`
sidekick.nvim	`sidekick`
snacks.nvim	`snacks`
vim-sneak	`sneak`
supermaven-nvim	`supermaven`
telescope.nvim	`telescope`
nvim-treesitter-context	`treesitter-context`
trouble.nvim	`trouble`
vimwiki	`vimwiki`
which-key.nvim	`which-key`
yanky.nvim	`yanky`

🍭 Extras

Tool	Extra
Aerc	extras/aerc
Aider	extras/aider
Alacritty	extras/alacritty
Btop++	extras/btop
Delta	extras/delta
(Better-)Discord	extras/discord
Dunst	extras/dunst
eza	extras/eza
Fish	extras/fish
Fish Themes	extras/fish_themes
Foot	extras/foot
Fuzzel	extras/fuzzel
Fzf	extras/fzf
Gemini CLI	extras/gemini_cli
Ghostty	extras/ghostty
GitUI	extras/gitui
GNOME Terminal	extras/gnome_terminal
Helix	extras/helix
iSH	extras/ish
iTerm	extras/iterm
Kitty	extras/kitty
Konsole	extras/konsole
Lazygit	extras/lazygit
Lua Table for testing	extras/lua
opencode	extras/opencode
pi	extras/pi
Prism	extras/prism
process-compose	extras/process_compose
QTerminal	extras/qterminal
Slack	extras/slack
Spotify Player	extras/spotify_player
Sublime Text	extras/sublime
Tailwind CSS (v4)	extras/tailwindv4
Terminator	extras/terminator
Termux	extras/termux
Tilix	extras/tilix
Tmux	extras/tmux
Vim	extras/vim
Vimium	extras/vimium
Vivaldi	extras/vivaldi
WezTerm	extras/wezterm
Windows Terminal	extras/windows_terminal
Xfce Terminal	extras/xfceterm
Xresources	extras/xresources
Yazi	extras/yazi
Zathura	extras/zathura
Zellij	extras/zellij

⚡️ Requirements

Neovim >= 0.8.0

📦 Installation

Install the theme with your preferred package manager, such as folke/lazy.nvim:

{
  "folke/tokyonight.nvim",
  lazy = false,
  priority = 1000,
  opts = {},
}

🚀 Usage

vim.cmd[[colorscheme tokyonight]]

colorscheme tokyonight

" There are also colorschemes for the different styles.
colorscheme tokyonight-night
colorscheme tokyonight-storm
colorscheme tokyonight-day
colorscheme tokyonight-moon

Some plugins need extra configuration to work with TokyoNight.

Click here for more details

Barbecue

-- Lua
require('barbecue').setup {
  -- ... your barbecue config
  theme = 'tokyonight',
  -- ... your barbecue config
}

Lualine

-- Lua
require('lualine').setup {
  options = {
    -- ... your lualine config
    theme = 'tokyonight'
    -- ... your lualine config
  }
}

Lightline

" Vim Script
let g:lightline = {'colorscheme': 'tokyonight'}

⚙️ Configuration

Important

Set the configuration BEFORE loading the color scheme with colorscheme tokyonight.

The theme offers four styles: storm, moon, night, and day.

The day style is used when { style = "day" } is passed to setup(options) or when vim.o.background = "light".

TokyoNight uses the default options, unless setup is explicitly called.

Default Options

---@class tokyonight.Config
---@field on_colors fun(colors: ColorScheme)
---@field on_highlights fun(highlights: tokyonight.Highlights, colors: ColorScheme)
M.defaults = {
  style = "moon", -- The theme comes in three styles, `storm`, a darker variant `night` and `day`
  light_style = "day", -- The theme is used when the background is set to light
  transparent = false, -- Enable this to disable setting the background color
  terminal_colors = true, -- Configure the colors used when opening a `:terminal` in Neovim
  styles = {
    -- Style to be applied to different syntax groups
    -- Value is any valid attr-list value for `:help nvim_set_hl`
    comments = { italic = true },
    keywords = { italic = true },
    functions = {},
    variables = {},
    -- Background styles. Can be "dark", "transparent" or "normal"
    sidebars = "dark", -- style for sidebars, see below
    floats = "dark", -- style for floating windows
  },
  day_brightness = 0.3, -- Adjusts the brightness of the colors of the **Day** style. Number between 0 and 1, from dull to vibrant colors
  dim_inactive = false, -- dims inactive windows
  lualine_bold = false, -- When `true`, section headers in the lualine theme will be bold

  --- You can override specific color groups to use other groups or a hex color
  --- function will be called with a ColorScheme table
  ---@param colors ColorScheme
  on_colors = function(colors) end,

  --- You can override specific highlights to use other groups or a hex color
  --- function will be called with a Highlights and ColorScheme table
  ---@param highlights tokyonight.Highlights
  ---@param colors ColorScheme
  on_highlights = function(highlights, colors) end,

  cache = true, -- When set to true, the theme will be cached for better performance

  ---@type table<string, boolean|{enabled:boolean}>
  plugins = {
    -- enable all plugins when not using lazy.nvim
    -- set to false to manually enable/disable plugins
    all = package.loaded.lazy == nil,
    -- uses your plugin manager to automatically enable needed plugins
    -- currently only lazy.nvim is supported
    auto = true,
    -- add any plugins here that you want to enable
    -- for all possible plugins, see:
    --   * https://github.com/folke/tokyonight.nvim/tree/main/lua/tokyonight/groups
    -- telescope = true,
  },
}

🪓 Overriding Colors & Highlight Groups

How the highlight groups are calculated:

colors are determined based on your configuration, with the ability to override them using config.on_colors(colors).
These colors are utilized to generate the highlight groups.
config.on_highlights(highlights, colors) can be used to override highlight groups.

For default values of colors and highlights, please consult the storm, moon, night, and day themes.

Settings & Changing Colors

require("tokyonight").setup({
  -- use the night style
  style = "night",
  -- disable italic for functions
  styles = {
    functions = {}
  },
  -- Change the "hint" color to the "orange" color, and make the "error" color bright red
  on_colors = function(colors)
    colors.hint = colors.orange
    colors.error = "#ff0000"
  end
})

Borderless Telescope

require("tokyonight").setup({
  on_highlights = function(hl, c)
    local prompt = "#2d3149"
    hl.TelescopeNormal = {
      bg = c.bg_dark,
      fg = c.fg_dark,
    }
    hl.TelescopeBorder = {
      bg = c.bg_dark,
      fg = c.bg_dark,
    }
    hl.TelescopePromptNormal = {
      bg = prompt,
    }
    hl.TelescopePromptBorder = {
      bg = prompt,
      fg = prompt,
    }
    hl.TelescopePromptTitle = {
      bg = prompt,
      fg = prompt,
    }
    hl.TelescopePreviewTitle = {
      bg = c.bg_dark,
      fg = c.bg_dark,
    }
    hl.TelescopeResultsTitle = {
      bg = c.bg_dark,
      fg = c.bg_dark,
    }
  end,
})

Fix undercurls in Tmux

To have undercurls show up and in color, add the following to your Tmux configuration file:

# Undercurl
set -g default-terminal "${TERM}"
set -as terminal-overrides ',*:Smulx=\E[4::%p1%dm'  # undercurl support
set -as terminal-overrides ',*:Setulc=\E[58::2::::%p1%{65536}%/%d::%p1%{256}%/%{255}%&%d::%p1%{255}%&%d%;m'  # underscore colours - needs tmux-3.0

🍭 Extras

Extra color configs for Kitty, Alacritty, Fish, WezTerm, iTerm and foot can be found in extras. To use them, refer to their respective documentation.

You can easily use the color palette for other plugins inside your Neovim configuration:

local colors = require("tokyonight.colors").setup() -- pass in any of the config options as explained above
local util = require("tokyonight.util")

aplugin.background = colors.bg_dark
aplugin.my_error = util.lighten(colors.red1, 0.3) -- number between 0 and 1. 0 results in white, 1 results in red1

🔥 Contributing

Pull requests are welcome! Please see CONTRIBUTING.md for guidelines on adding new extras and general contribution guidelines.

pterodactyl/game-eggs

Pterodactyl Game Eggs

Game egg list

Below is a categorized list of games with links to their respective server configurations and mod files. Click on each game to explore further.

7 Days to Die

Abiotic Factor

Aloft

Americas Army

Proving Grounds

Among Us

ARK

Arma

Aska

Assetto Corsa

Astroneer

Astro Colony

Automobilista 2

Avorion

Barotrauma

Banana Shooter

BATTALION Legacy

BeamNG

Black Mesa

Brickadia

Citadel

ClassiCube

MCGalaxy

Clone Hero

Call of Duty / COD

IW4X

Colony Survival

Conan Exiles

Contagion)

Core Keeper

Counter-Strike

Craftopia

CryoFall

CS2D

Cube Engine

Cubic Odyssey

DayZ

DDNet

DDRace Network

Dead Matter

Don't Starve

Doom

Zandronum

Eco

Escape from Tarkov (EFT)

Empyrion

Enshrouded

Factorio

Fistful of Frags (FoF)

FortressCraft Evolved

Foundry

Foundry Virtual Tabletop (VTT)

Frozen Flame

FTL Tachyon

Garry's Mod (GMod)

Ground Branch

Grand Theft Auto (GTA)

Half-Life Dedicated Server (HLDS)

Hogwarp

Holdfast

HumanitZ

Hurtworld

Hytale

Icarus

Insurgency: Sandstorm

IOSoccer

Just Cause

Just Cause 3

Killing Floor 2

Kerbal Space Program (KSP)

League Sandbox

Left 4 Dead Series

Longvinter

Los Angeles Crimes

Midnight Ghost Hunt

Mindustry

Minecraft

Bedrock Edition
Crossplay
Java Edition
- CanvasMC
- Cuberite
- CurseForge
- Fabric
- Forge
- Technic

Minetest

Modiverse

Medal of Honor: Allied Assault (MoHAA)

Mordhau

Mount & Blade II: Bannerlord

Myth of Empires

Necesse

Neos VR

Neverwinter Nights: Enhanced Edition

Nightingale

Night of the Dead

No More Room in Hell (NMRIH)

Novalife Amboise

No Love Lost

No One Survived

Nuclear Option

Onset

OpenArena

OpenRA

OpenRCT2

OpenTTD

Operation Harsh Doorstop

Palworld

Path of Titans

Pavlov VR

Renown

SCUM

Plains of Pain

Puck

Sonic Robo Blast 2 (SRB2)

Soldat 2

Sunkenland

Voyager of Nera

Windrose

Wine Generic

Wolfenstein: Enemy Territory (ET Legacy)

Wurm Unlimited

Xonotic

For detailed configuration files, mod support, or server setup guides, refer to each game's folder. Please submit issues or pull requests for any improvements or additions.

LazyVim/LazyVim

Neovim config for the lazy

Install · Configure · Docs

LazyVim is a Neovim setup powered by 💤 lazy.nvim to make it easy to customize and extend your config. Rather than having to choose between starting from scratch or using a pre-made distro, LazyVim offers the best of both worlds - the flexibility to tweak your config as needed, along with the convenience of a pre-configured setup.

✨ Features

🔥 Transform your Neovim into a full-fledged IDE
💤 Easily customize and extend your config with lazy.nvim
🚀 Blazingly fast
🧹 Sane default settings for options, autocmds, and keymaps
📦 Comes with a wealth of plugins pre-configured and ready to use

⚡️ Requirements

Neovim >= 0.11.2 (needs to be built with LuaJIT)
Git >= 2.19.0 (for partial clones support)
a Nerd Font (optional)
a C compiler for nvim-treesitter. See here

🚀 Getting Started

You can find a starter template for LazyVim here

Try it with Docker

docker run -w /root -it --rm alpine:edge sh -uelic '
  apk add git lazygit fzf curl neovim ripgrep alpine-sdk --update
  git clone https://github.com/LazyVim/starter ~/.config/nvim
  cd ~/.config/nvim
  nvim
'

Install the LazyVim Starter

Make a backup of your current Neovim files:

mv ~/.config/nvim ~/.config/nvim.bak
mv ~/.local/share/nvim ~/.local/share/nvim.bak

Clone the starter

git clone https://github.com/LazyVim/starter ~/.config/nvim

Remove the .git folder, so you can add it to your own repo later
```
rm -rf ~/.config/nvim/.git
```
Start Neovim!
```
nvim
```
Refer to the comments in the files on how to customize LazyVim.

@dusty-phillips wrote a comprehensive book called LazyVim for Ambitious Developers available for free online.

📂 File Structure

The files under config will be automatically loaded at the appropriate time, so you don't need to require those files manually. LazyVim comes with a set of default config files that will be loaded before your own. See here

You can add your custom plugin specs under lua/plugins/. All files there will be automatically loaded by lazy.nvim

~/.config/nvim
├── lua
│   ├── config
│   │   ├── autocmds.lua
│   │   ├── keymaps.lua
│   │   ├── lazy.lua
│   │   └── options.lua
│   └── plugins
│       ├── spec1.lua
│       ├── **
│       └── spec2.lua
└── init.lua

⚙️ Configuration

Refer to the docs

windwp/nvim-ts-autotag

Use treesitter to auto close and auto rename html tag

nvim-ts-autotag

Use treesitter to autoclose and autorename html tag

It works with:

astro
dot
glimmer
handlebars
html
javascript
jsx
liquid
vento
markdown
php
rescript
svelte
tsx
twig
typescript
vue
xml

and more

Usage

Before        Input         After
------------------------------------
<div           >              <div></div>
<div></div>    ciwspan<esc>   <span></span>
------------------------------------

Setup

Requires Nvim 0.9.5 and up.

Note that nvim-ts-autotag will not work unless you have treesitter parsers (like html) installed for a given filetype. See nvim-treesitter for installing parsers.

require('nvim-ts-autotag').setup({
  opts = {
    -- Defaults
    enable_close = true, -- Auto close tags
    enable_rename = true, -- Auto rename pairs of tags
    enable_close_on_slash = false -- Auto close on trailing </
  },
  -- Also override individual filetype configs, these take priority.
  -- Empty by default, useful if one of the "opts" global settings
  -- doesn't work well in a specific filetype
  per_filetype = {
    ["html"] = {
      enable_close = false
    }
  }
})

Caution

If you are setting up via nvim-treesitter.configs it has been deprecated! Please migrate to the new way. It will be removed in 1.0.0.

A note on lazy loading

For those of you using lazy loading through a plugin manager (like lazy.nvim) lazy loading is not particularly necessary for this plugin. nvim-ts-autotag is efficient in choosing when it needs to load. If you still insist on lazy loading nvim-ts-autotag, then two good events to use are BufReadPre & BufNewFile.

Extending the default config

Let's say that there's a language that nvim-ts-autotag doesn't currently support and you'd like to support it in your config. While it would be the preference of the author that you upstream your changes, perhaps you would rather not 😢.

For example, if you have a language that has a very similar layout in its Treesitter Queries as html, you could add an alias like so:

require('nvim-ts-autotag').setup({
  aliases = {
    ["your language here"] = "html",
  }
})

-- or
local TagConfigs = require("nvim-ts-autotag.config.init")
TagConfigs:add_alias("your language here", "html")

That will make nvim-ts-autotag close tags according to the rules of the html config in the given language.

But what if a parser breaks for whatever reason, for example the upstream Treesitter tree changes its node names and now the default queries that nvim-ts-autotag provides no longer work.

Fear not! You can directly extend and override the existing configs. For example, let's say the start and end tag patterns have changed for xml. We can directly override the xml config:

local TagConfigs = require("nvim-ts-autotag.config.init")
TagConfigs:update(TagConfigs:get("xml"):override("xml", {
    start_tag_pattern = { "STag" },
    end_tag_pattern = { "ETag" },
}))

In fact, this very nearly what we do during our own internal initialization phase for nvim-ts-autotag.

Enable update on insert

If you have that issue #19

vim.lsp.handlers['textDocument/publishDiagnostics'] = vim.lsp.with(
    vim.lsp.diagnostic.on_publish_diagnostics,
    {
        underline = true,
        virtual_text = {
            spacing = 5,
            severity_limit = 'Warning',
        },
        update_in_insert = true,
    }
)

Contributors

Thank @PriceHiller for his work on this plugin.

Sponsor

If you find this plugin useful, please consider sponsoring the project.

Sponsor

DataDog/kong-plugin-ddtrace

Datadog APM Plugin for Kong Gateway

Kong Plugin for Datadog APM

The kong-plugin-ddtrace is a Datadog APM plugin designed to integrate seamlessly with the Kong Gateway. This plugin enables detailed tracing of requests passing through Kong, providing insights into the performance and behavior of your APIs.

Features

Detailed Tracing: Capture and report trace data to the Datadog Agent, allowing you to monitor and diagnose performance issues in real-time.
Real-Time Monitoring: Integrate with Datadog to monitor API performance and diagnose issues in real-time.
Configurable: Supports a wide range of configuration options to tailor tracing to your specific needs.
Compatibility: Works with various Kong deployment environments, including Kubernetes.

Getting Started

Important

This plugin is compatible with Kong Gateway v3.4 LTS (>= v3.4.3.5) or newer. For older version of Kong, please use v0.2.2 or older versions.

Prerequisites

Kong Gateway installed and running.
Datadog Agent installed and configured.
API key for Datadog.

Installation

luarocks install kong-plugin-ddtrace

Usage

Kong Admin API:

# Enabled globally
curl -i -X POST --url http://${KONG_ADMIN_HOST}:${KONG_ADMIN_PORT}/plugins/ --data 'name=ddtrace'

# Enabled for specific service only
curl -i -X POST --url http://${KONG_ADMIN_HOST}:${KONG_ADMIN_PORT}/services/example-service/plugins/ --data 'name=ddtrace'

Kong DB-less:

# Enable for a specific service
_format_version: "3.0"
_transform: true

services:
- name: example-service
  url: http://httpbin.org/headers
  plugins:
  - name: ddtrace
    config:
      service_name: example-service
      agent_host: datadog-agent
  routes:
  - name: my-route
    paths:
    - /

Configuration

This plugin supports a number of configuration options. These can be supplied when registering the plugin or by setting environment variables.

More details on the Configuration page.

Support

For support, please open an issue on the GitHub repository or contact Datadog support.

Contributing

Contributions are welcome! Please read the contributing guidelines and follow the best practices outlined in the project documentation.

License

This project is licensed under the Apache License 2.0. See the LICENSE file for details.

folke/noice.nvim

💥 Highly experimental plugin that completely replaces the UI for messages, cmdline and the popupmenu.

💥 Noice (Nice, Noise, Notice)

Highly experimental plugin that completely replaces the UI for messages, cmdline and the popupmenu.

✨ Features

🌅 fully configurable views like nvim-notify, splits, popups, virtual text, ..
🔍 use filters to route messages to different views
🌈 message highlights are preserved in the views (like the colors of :hi)
📝 command output like :messages is shown in normal buffers, which makes it much easier to work with
📚 :Noice command to show a full message history
⌨️ no more :h more-prompt
💻 fully customizable cmdline with icons
💅 syntax highlighting for vim and lua on the cmdline
🚥 statusline components
🔭 open message history in telescope.nvim or fzf-lua

🔥 Status

Noice is using the new experimental vim.ui_attach API, so issues are to be expected. It is highly recommended to use Neovim nightly, since a bunch of issues have already been fixed upstream. Check this tracking issue for a list of known issues.

⚡️ Requirements

Neovim >= 0.9.0 (nightly highly recommended)
nui.nvim: used for proper rendering and multiple views
nvim-notify: notification view (optional)
a Nerd Font (optional)
nvim-treesitter (optional, but highly recommended) used for highlighting the cmdline and lsp docs. Make sure to install the parsers for vim, regex, lua, bash, markdown and markdown_inline

📦 Installation

Install the plugin with your preferred package manager:

-- lazy.nvim
{
  "folke/noice.nvim",
  event = "VeryLazy",
  opts = {
    -- add any options here
  },
  dependencies = {
    -- if you lazy-load any plugin below, make sure to add proper `module="..."` entries
    "MunifTanjim/nui.nvim",
    -- OPTIONAL:
    --   `nvim-notify` is only needed, if you want to use the notification view.
    --   If not available, we use `mini` as the fallback
    "rcarriga/nvim-notify",
    }
}

Suggested setup:

require("noice").setup({
  lsp = {
    -- override markdown rendering so that **cmp** and other plugins use **Treesitter**
    override = {
      ["vim.lsp.util.convert_input_to_markdown_lines"] = true,
      ["vim.lsp.util.stylize_markdown"] = true,
      ["cmp.entry.get_documentation"] = true, -- requires hrsh7th/nvim-cmp
    },
  },
  -- you can enable a preset for easier configuration
  presets = {
    bottom_search = true, -- use a classic bottom cmdline for search
    command_palette = true, -- position the cmdline and popupmenu together
    long_message_to_split = true, -- long messages will be sent to a split
    inc_rename = false, -- enables an input dialog for inc-rename.nvim
    lsp_doc_border = false, -- add a border to hover docs and signature help
  },
})

It's a good idea to run :checkhealth noice after installing to check for common issues.

vim-plug

" vim-plug
call plug#begin()
  Plug 'folke/noice.nvim'
  Plug 'MunifTanjim/nui.nvim'
call plug#end()

lua require("noice").setup()

⚙️ Configuration

noice.nvim comes with the following defaults:

Check the wiki for configuration recipes.

{
  cmdline = {
    enabled = true, -- enables the Noice cmdline UI
    view = "cmdline_popup", -- view for rendering the cmdline. Change to `cmdline` to get a classic cmdline at the bottom
    opts = {}, -- global options for the cmdline. See section on views
    ---@type table<string, CmdlineFormat>
    format = {
      -- conceal: (default=true) This will hide the text in the cmdline that matches the pattern.
      -- view: (default is cmdline view)
      -- opts: any options passed to the view
      -- icon_hl_group: optional hl_group for the icon
      -- title: set to anything or empty string to hide
      cmdline = { pattern = "^:", icon = "", lang = "vim" },
      search_down = { kind = "search", pattern = "^/", icon = " ", lang = "regex" },
      search_up = { kind = "search", pattern = "^%?", icon = " ", lang = "regex" },
      filter = { pattern = "^:%s*!", icon = "$", lang = "bash" },
      lua = { pattern = { "^:%s*lua%s+", "^:%s*lua%s*=%s*", "^:%s*=%s*" }, icon = "", lang = "lua" },
      help = { pattern = "^:%s*he?l?p?%s+", icon = "" },
      input = { view = "cmdline_input", icon = "󰥻 " }, -- Used by input()
      -- lua = false, -- to disable a format, set to `false`
    },
  },
  messages = {
    -- NOTE: If you enable messages, then the cmdline is enabled automatically.
    -- This is a current Neovim limitation.
    enabled = true, -- enables the Noice messages UI
    view = "notify", -- default view for messages
    view_error = "notify", -- view for errors
    view_warn = "notify", -- view for warnings
    view_history = "messages", -- view for :messages
    view_search = "virtualtext", -- view for search count messages. Set to `false` to disable
  },
  popupmenu = {
    enabled = true, -- enables the Noice popupmenu UI
    ---@type 'nui'|'cmp'
    backend = "nui", -- backend to use to show regular cmdline completions
    ---@type NoicePopupmenuItemKind|false
    -- Icons for completion item kinds (see defaults at noice.config.icons.kinds)
    kind_icons = {}, -- set to `false` to disable icons
  },
  -- default options for require('noice').redirect
  -- see the section on Command Redirection
  ---@type NoiceRouteConfig
  redirect = {
    view = "popup",
    filter = { event = "msg_show" },
  },
  -- You can add any custom commands below that will be available with `:Noice command`
  ---@type table<string, NoiceCommand>
  commands = {
    history = {
      -- options for the message history that you get with `:Noice`
      view = "split",
      opts = { enter = true, format = "details" },
      filter = {
        any = {
          { event = "notify" },
          { error = true },
          { warning = true },
          { event = "msg_show", kind = { "" } },
          { event = "lsp", kind = "message" },
        },
      },
    },
    -- :Noice last
    last = {
      view = "popup",
      opts = { enter = true, format = "details" },
      filter = {
        any = {
          { event = "notify" },
          { error = true },
          { warning = true },
          { event = "msg_show", kind = { "" } },
          { event = "lsp", kind = "message" },
        },
      },
      filter_opts = { count = 1 },
    },
    -- :Noice errors
    errors = {
      -- options for the message history that you get with `:Noice`
      view = "popup",
      opts = { enter = true, format = "details" },
      filter = { error = true },
      filter_opts = { reverse = true },
    },
    all = {
      -- options for the message history that you get with `:Noice`
      view = "split",
      opts = { enter = true, format = "details" },
      filter = {},
    },
  },
  notify = {
    -- Noice can be used as `vim.notify` so you can route any notification like other messages
    -- Notification messages have their level and other properties set.
    -- event is always "notify" and kind can be any log level as a string
    -- The default routes will forward notifications to nvim-notify
    -- Benefit of using Noice for this is the routing and consistent history view
    enabled = true,
    view = "notify",
  },
  lsp = {
    progress = {
      enabled = true,
      -- Lsp Progress is formatted using the builtins for lsp_progress. See config.format.builtin
      -- See the section on formatting for more details on how to customize.
      --- @type NoiceFormat|string
      format = "lsp_progress",
      --- @type NoiceFormat|string
      format_done = "lsp_progress_done",
      throttle = 1000 / 30, -- frequency to update lsp progress message
      view = "mini",
    },
    override = {
      -- override the default lsp markdown formatter with Noice
      ["vim.lsp.util.convert_input_to_markdown_lines"] = false,
      -- override the lsp markdown formatter with Noice
      ["vim.lsp.util.stylize_markdown"] = false,
      -- override cmp documentation with Noice (needs the other options to work)
      ["cmp.entry.get_documentation"] = false,
    },
    hover = {
      enabled = true,
      silent = false, -- set to true to not show a message if hover is not available
      view = nil, -- when nil, use defaults from documentation
      ---@type NoiceViewOptions
      opts = {}, -- merged with defaults from documentation
    },
    signature = {
      enabled = true,
      auto_open = {
        enabled = true,
        trigger = true, -- Automatically show signature help when typing a trigger character from the LSP
        luasnip = true, -- Will open signature help when jumping to Luasnip insert nodes
        throttle = 50, -- Debounce lsp signature help request by 50ms
      },
      view = nil, -- when nil, use defaults from documentation
      ---@type NoiceViewOptions
      opts = {}, -- merged with defaults from documentation
    },
    message = {
      -- Messages shown by lsp servers
      enabled = true,
      view = "notify",
      opts = {},
    },
    -- defaults for hover and signature help
    documentation = {
      view = "hover",
      ---@type NoiceViewOptions
      opts = {
        lang = "markdown",
        replace = true,
        render = "plain",
        format = { "{message}" },
        win_options = { concealcursor = "n", conceallevel = 3 },
      },
    },
  },
  markdown = {
    hover = {
      ["|(%S-)|"] = vim.cmd.help, -- vim help links
      ["%[.-%]%((%S-)%)"] = require("noice.util").open, -- markdown links
    },
    highlights = {
      ["|%S-|"] = "@text.reference",
      ["@%S+"] = "@parameter",
      ["^%s*(Parameters:)"] = "@text.title",
      ["^%s*(Return:)"] = "@text.title",
      ["^%s*(See also:)"] = "@text.title",
      ["{%S-}"] = "@parameter",
    },
  },
  health = {
    checker = true, -- Disable if you don't want health checks to run
  },
  ---@type NoicePresets
  presets = {
    -- you can enable a preset by setting it to true, or a table that will override the preset config
    -- you can also add custom presets that you can enable/disable with enabled=true
    bottom_search = false, -- use a classic bottom cmdline for search
    command_palette = false, -- position the cmdline and popupmenu together
    long_message_to_split = false, -- long messages will be sent to a split
    inc_rename = false, -- enables an input dialog for inc-rename.nvim
    lsp_doc_border = false, -- add a border to hover docs and signature help
  },
  throttle = 1000 / 30, -- how frequently does Noice need to check for ui updates? This has no effect when in blocking mode.
  ---@type NoiceConfigViews
  views = {}, ---@see section on views
  ---@type NoiceRouteConfig[]
  routes = {}, --- @see section on routes
  ---@type table<string, NoiceFilter>
  status = {}, --- @see section on statusline components
  ---@type NoiceFormatOptions
  format = {}, --- @see section on formatting
}

If you don't want to use a Nerd Font, you can replace the icons with Unicode symbols.

  require("noice").setup({
    cmdline = {
      format = {
        cmdline = { icon = ">" },
        search_down = { icon = "🔍⌄" },
        search_up = { icon = "🔍⌃" },
        filter = { icon = "$" },
        lua = { icon = "☾" },
        help = { icon = "?" },
      },
    },
    format = {
      level = {
        icons = {
          error = "✖",
          warn = "▼",
          info = "●",
        },
      },
    },
    popupmenu = {
      kind_icons = false,
    },
    inc_rename = {
      cmdline = {
        format = {
          IncRename = { icon = "⟳" },
        },
      },
    },
  })

🔍 Filters

Noice uses filters to route messages to specific views.

Name	Type	Description
any	`filter[]`	checks that at least one of the filters matches
blocking	`boolean`	are we in blocking mode?
cleared	`boolean`	checks if the message is cleared, meaning it's in the history
cmdline	`boolean` or `string`	checks if the message was generated by executing a cmdline. When `string`, then it is used as a pattern
error	`boolean`	all error-like kinds from `ext_messages`
event	`string` or `string[]`	any of the events from `ext_messages` or `cmdline`. See :h ui-messages
find	`string`	uses lua `string.find` to match the pattern
has	`boolean`	checks if the message is exists, meaning it's in the history
kind	`string` or `string[]`	any of the kinds from `ext_messages`. See :h ui-messages
max_height	`number`	maximum height of the message
max_length	`number`	maximum length of the message (total width of all the lines)
max_width	`number`	maximum width of the message
min_height	`number`	minimum height of the message
min_length	`number`	minimum length of the message (total width of all the lines)
min_width	`number`	minimum width of the message
mode	`string`	checks if `vim.api.nvim_get_mode()` contains the given mode
not	`filter`	checks whether the filter matches or not
warning	`boolean`	all warning-like kinds from `ext_messages`

Example:

-- all messages over 10 lines, excluding echo and search_count
local filter = {
  event = "msg_show",
  min_height = 10,
  ["not"] = { kind = { "search_count", "echo" } },
}

🌅 Views

Noice comes with the following built-in backends:

popup: powered by nui.nvim
split: powered by nui.nvim
notify: powered by nvim-notify
virtualtext: shows the message as virtualtext (for example for search_count)
mini: similar to notifier.nvim & fidget.nvim
notify_send: generate a desktop notification

A View (config.views) is a combination of a backend and options. Noice comes with the following built-in views with sane defaults:

View	Backend	Description
notify	`notify`	nvim-notify with `level=nil`, `replace=false`, `merge=false`
split	`split`	horizontal split
vsplit	`split`	vertical split
popup	`popup`	simple popup
mini	`mini`	minimal view, by default bottom right, right-aligned
cmdline	`popup`	bottom line, similar to the classic cmdline
cmdline_popup	`popup`	fancy cmdline popup, with different styles according to the cmdline mode
cmdline_output	`split`	split used by `config.presets.cmdline_output_to_split`
messages	`split`	split used for `:messages`
confirm	`popup`	popup used for `confirm` events
hover	`popup`	popup used for lsp signature help and hover
popupmenu	`nui.menu`	special view with the options used to render the popupmenu when backend is nui

Please refer to noice.config.views to see the options. Any options passed to existing views in config.views, will override those options only. You can configure completely new views and use them in custom routes.

Example:

-- override the default split view to always enter the split when it opens
require("noice").setup({
  views = {
    split = {
      enter = true,
    },
  },
})

All built-in Noice views have the filetype noice

Nui Options

See the Nui documentation for Popup and Split.

Option	Description
size, position	Size, position and their constituents can additionally be specified as "auto", to use the message height and width.
win_options.winhighlight	String or can also be a table like: `{ win_options = { winhighlight = { Normal = "NormalFloat", FloatBorder = "FloatBorder" }, } }`
scrollbar	Set to `false` to hide the scrollbar.

Notify Options

Option	Type	Default	Description
title	`string`	`"Notification"`	title to be used for the notification. Uses `Message.title` if available.
replace	`boolean`	`false`	when true, messages routing to the same notify instance will replace existing messages instead of pushing a new notification every time
merge	`boolean`	`false`	Merge messages into one Notification or create separate notifications
level	`number\|string`	`nil`	notification level. Uses `Message.level` if available.

Virtual Text Options

Right now there's only an option to set the hl_group used to render the virtual text.

🎨 Formatting

Formatting options can be specified with config.format. For a list of the defaults, please refer to config.format

Noice includes the following formatters:

level: message level with optional icon and hl_group per level
text: any text with optional hl_group
title: message title with optional hl_group
event: message event with optional hl_group
kind: message kind with optional hl_group
date: formatted date with optional date format string
message: message content itself with optional hl_group to override message highlights
confirm: only useful for confirm messages. Will format the choices as buttons.
cmdline: will render the cmdline in the message that generated the message.
progress: progress bar used by lsp progress
spinner: spinners used by lsp progress
data: render any custom data from Message.opts. Useful in combination with the opts passed to vim.notify

Formatters are used in format definitions. Noice includes the following built-in formats:

{
  -- default format
  default = { "{level} ", "{title} ", "{message}" },
  -- default format for vim.notify views
  notify = { "{message}" },
  -- default format for the history
  details = {
    "{level} ",
    "{date} ",
    "{event}",
    { "{kind}", before = { ".", hl_group = "NoiceFormatKind" } },
    " ",
    "{title} ",
    "{cmdline} ",
    "{message}",
  },
  telescope = ..., -- formatter used to display telescope results
  telescope_preview = ..., -- formatter used to preview telescope results
  fzf = ..., -- formatter used to display fzf results
  fzf_preview = ..., -- formatter used to preview fzf results
  lsp_progress = ..., -- formatter used by lsp progress
  lsp_progress_done = ..., -- formatter used by lsp progress
}

Text before/after the formatter or in the before/after options, will only be rendered if the formatter itself rendered something.

The format view option, can be either a string (one of the built-in formats), or a table with a custom format definition.

To align text, you can use the align option for a view. Can be center, left or right.

🚗 Routes

A route has a filter, view and optional opts attribute.

view: one of the views (built-in or custom)
filter a filter for messages matching this route
opts: options for the view and the route

Route options can be any of the view options above, or one of:

Option	Type	Default	Description
skip	`boolean`	`false`	messages matching this filter will be skipped and not shown in any views
stop	`boolean`	`true`	When `false` and a route matches the filter, then other routes can still process the message too. Useful if you want certain messages to be shown in multiple views.

Please refer to noice.config.routes for an overview of the default routes. Routes passed to setup() will be prepended to the default routes.

Example

-- skip search_count messages instead of showing them as virtual text
require("noice").setup({
  routes = {
    {
      filter = { event = "msg_show", kind = "search_count" },
      opts = { skip = true },
    },
  },
})

-- always route any messages with more than 20 lines to the split view
require("noice").setup({
  routes = {
    {
      view = "split",
      filter = { event = "msg_show", min_height = 20 },
    },
  },
})

🚥 Statusline Components

Noice comes with the following statusline components:

ruler
message: last line of the last message (event=show_msg)
command: showcmd
mode: showmode (@recording messages)
search: search count messages

See noice.config.status for the default config.

You can add custom statusline components in setup under the status key.

Statusline components have the following methods:

get: gets the content of the message without highlights
get_hl: gets the content of the message with highlights
has: checks if the component is available

Example of configuring lualine.nvim

require("lualine").setup({
  sections = {
    lualine_x = {
      {
        require("noice").api.status.message.get_hl,
        cond = require("noice").api.status.message.has,
      },
      {
        require("noice").api.status.command.get,
        cond = require("noice").api.status.command.has,
        color = { fg = "#ff9e64" },
      },
      {
        require("noice").api.status.mode.get,
        cond = require("noice").api.status.mode.has,
        color = { fg = "#ff9e64" },
      },
      {
        require("noice").api.status.search.get,
        cond = require("noice").api.status.search.has,
        color = { fg = "#ff9e64" },
      },
    },
  },
})

🔭 Pickers

For convenience, you can do :Noice pick, which will open a picker with all the messages in the history, either with telescope or fzf-lua.

🔭 Telescope

In order to use Noice in Telescope, you can either do :Noice telescope, or register the extension and use :Telescope noice. The results panel is formatted using config.format.formatters.telescope. The preview is formatted with config.format.formatters.telescope_preview

require("telescope").load_extension("noice")

🔭 Fzf Lua

In order to use Noice in FzfLua, you can do :Noice fzf. The results panel is formatted using config.format.formatters.fzf. The preview is formatted with config.format.formatters.telescope_fzf

🚀 Usage

:Noice or :Noice history shows the message history
:Noice last shows the last message in a popup
:Noice dismiss dismiss all visible messages
:Noice errors shows the error messages in a split. Last errors on top
:Noice disable disables Noice
:Noice enable enables Noice
:Noice stats shows debugging stats
:Noice telescope opens message history in Telescope

Alternatively, all commands also exist as a full name like :NoiceLast, :NoiceDisable.

You can also use Lua equivalents.

vim.keymap.set("n", "<leader>nl", function()
  require("noice").cmd("last")
end)

vim.keymap.set("n", "<leader>nh", function()
  require("noice").cmd("history")
end)

You can add custom commands with config.commands

↪️ Command Redirection

Sometimes it's useful to redirect the messages generated by a command or function to a different view. That can be easily achieved with command redirection.

The redirect API can taken an optional routes parameter, which defaults to {config.redirect}.

-- redirect ":hi"
require("noice").redirect("hi")

-- redirect some function
require("noice").redirect(function()
  print("test")
end)

Adding the following keymap, will redirect the active cmdline when pressing <S-Enter>. The cmdline stays open, so you can change the command and execute it again. When exiting the cmdline, the popup window will be focused.

vim.keymap.set("c", "<S-Enter>", function()
  require("noice").redirect(vim.fn.getcmdline())
end, { desc = "Redirect Cmdline" })

Lsp Hover Doc Scrolling

vim.keymap.set({ "n", "i", "s" }, "<c-f>", function()
  if not require("noice.lsp").scroll(4) then
    return "<c-f>"
  end
end, { silent = true, expr = true })

vim.keymap.set({ "n", "i", "s" }, "<c-b>", function()
  if not require("noice.lsp").scroll(-4) then
    return "<c-b>"
  end
end, { silent = true, expr = true })

🌈 Highlight Groups

Click to see all highlight groups

Highlight Group	Default Group	Description
NoiceCmdline	MsgArea	Normal for the classic cmdline area at the bottom"
NoiceCmdlineIcon	DiagnosticSignInfo	Cmdline icon
NoiceCmdlineIconCalculator	NoiceCmdlineIcon
NoiceCmdlineIconCmdline	NoiceCmdlineIcon
NoiceCmdlineIconFilter	NoiceCmdlineIcon
NoiceCmdlineIconHelp	NoiceCmdlineIcon
NoiceCmdlineIconIncRename	NoiceCmdlineIcon
NoiceCmdlineIconInput	NoiceCmdlineIcon
NoiceCmdlineIconLua	NoiceCmdlineIcon
NoiceCmdlineIconSearch	DiagnosticSignWarn	Cmdline search icon (`/` and `?`)
NoiceCmdlinePopup	Normal	Normal for the cmdline popup
NoiceCmdlinePopupBorder	DiagnosticSignInfo	Cmdline popup border
NoiceCmdlinePopupBorderCalculator	NoiceCmdlinePopupBorder
NoiceCmdlinePopupBorderCmdline	NoiceCmdlinePopupBorder
NoiceCmdlinePopupBorderFilter	NoiceCmdlinePopupBorder
NoiceCmdlinePopupBorderHelp	NoiceCmdlinePopupBorder
NoiceCmdlinePopupBorderIncRename	NoiceCmdlinePopupBorder
NoiceCmdlinePopupBorderInput	NoiceCmdlinePopupBorder
NoiceCmdlinePopupBorderLua	NoiceCmdlinePopupBorder
NoiceCmdlinePopupBorderSearch	DiagnosticSignWarn	Cmdline popup border for search
NoiceCmdlinePopupTitle	DiagnosticSignInfo	Cmdline popup border
NoiceCmdlinePrompt	Title	prompt for input()
NoiceCompletionItemKindClass	NoiceCompletionItemKindDefault
NoiceCompletionItemKindColor	NoiceCompletionItemKindDefault
NoiceCompletionItemKindConstant	NoiceCompletionItemKindDefault
NoiceCompletionItemKindConstructor	NoiceCompletionItemKindDefault
NoiceCompletionItemKindDefault	Special
NoiceCompletionItemKindEnum	NoiceCompletionItemKindDefault
NoiceCompletionItemKindEnumMember	NoiceCompletionItemKindDefault
NoiceCompletionItemKindField	NoiceCompletionItemKindDefault
NoiceCompletionItemKindFile	NoiceCompletionItemKindDefault
NoiceCompletionItemKindFolder	NoiceCompletionItemKindDefault
NoiceCompletionItemKindFunction	NoiceCompletionItemKindDefault
NoiceCompletionItemKindInterface	NoiceCompletionItemKindDefault
NoiceCompletionItemKindKeyword	NoiceCompletionItemKindDefault
NoiceCompletionItemKindMethod	NoiceCompletionItemKindDefault
NoiceCompletionItemKindModule	NoiceCompletionItemKindDefault
NoiceCompletionItemKindProperty	NoiceCompletionItemKindDefault
NoiceCompletionItemKindSnippet	NoiceCompletionItemKindDefault
NoiceCompletionItemKindStruct	NoiceCompletionItemKindDefault
NoiceCompletionItemKindText	NoiceCompletionItemKindDefault
NoiceCompletionItemKindUnit	NoiceCompletionItemKindDefault
NoiceCompletionItemKindValue	NoiceCompletionItemKindDefault
NoiceCompletionItemKindVariable	NoiceCompletionItemKindDefault
NoiceCompletionItemMenu	none	Normal for the popupmenu
NoiceCompletionItemWord	none	Normal for the popupmenu
NoiceConfirm	Normal	Normal for the confirm view
NoiceConfirmBorder	DiagnosticSignInfo	Border for the confirm view
NoiceCursor	Cursor	Fake Cursor
NoiceFormatConfirm	CursorLine
NoiceFormatConfirmDefault	Visual
NoiceFormatDate	Special
NoiceFormatEvent	NonText
NoiceFormatKind	NonText
NoiceFormatLevelDebug	NonText
NoiceFormatLevelError	DiagnosticVirtualTextError
NoiceFormatLevelInfo	DiagnosticVirtualTextInfo
NoiceFormatLevelOff	NonText
NoiceFormatLevelTrace	NonText
NoiceFormatLevelWarn	DiagnosticVirtualTextWarn
NoiceFormatProgressDone	Search	Progress bar done
NoiceFormatProgressTodo	CursorLine	progress bar todo
NoiceFormatTitle	Title
NoiceLspProgressClient	Title	Lsp progress client name
NoiceLspProgressSpinner	Constant	Lsp progress spinner
NoiceLspProgressTitle	NonText	Lsp progress title
NoiceMini	MsgArea	Normal for mini view
NoicePopup	NormalFloat	Normal for popup views
NoicePopupBorder	FloatBorder	Border for popup views
NoicePopupmenu	Pmenu	Normal for the popupmenu
NoicePopupmenuBorder	FloatBorder	Popupmenu border
NoicePopupmenuMatch	Special	Part of the item that matches the input
NoicePopupmenuSelected	PmenuSel	Selected item in the popupmenu
NoiceScrollbar	PmenuSbar	Normal for scrollbar
NoiceScrollbarThumb	PmenuThumb	Scrollbar thumb
NoiceSplit	NormalFloat	Normal for split views
NoiceSplitBorder	FloatBorder	Border for split views
NoiceVirtualText	DiagnosticVirtualTextInfo	Default hl group for virtualtext views

catppuccin/nvim

🍨 Soothing pastel theme for Neovim

Catppuccin for Neovim

This port of Catppuccin is special because it was the first one and the one that originated the project itself. Given this, it's important to acknowledge that it all didn't come to be what it is now out of nowhere. So, if you are interested in knowing more about the initial stages of the theme, you can find it under the v0.1 tag.

Previews

🌻 Latte

🪴 Frappé

🌺 Macchiato

🌿 Mocha

Features

Supports Neovim >= 0.8
Highly configurable with 4 different flavours and the ability to create your own!
Compiled configuration for fast startup time
Integrations with lsp, treesitter and a bunch of plugins
Support for many other applications

Installation

with Neovim 0.12's vim.pack

vim.pack.add { { src = "https://github.com/catppuccin/nvim", name = "catppuccin" } }

lazy.nvim

{ "catppuccin/nvim", name = "catppuccin", priority = 1000 }

packer.nvim

use { "catppuccin/nvim", as = "catppuccin" }

rocks.nvim

:Rocks install catppuccin.nvim

Vim support

Support for Vim is provided through the vim branch.

vim-plug

Plug 'catppuccin/nvim', { 'branch': 'vim', 'as': 'catppuccin' }

Note

Keep in mind that Vim support has been dropped (#949) and this branch won't receive further updates unless necessary. For full Vim support, see catppuccin/vim. Starting from Vim v9.2.0219 and Neovim 0.12, catppuccin is shipped with the editors. Note that it is not maintained by the Catppuccin organization and follows Vim colorscheme rules instead of the official Catppuccin style guide.

Usage

colorscheme catppuccin-nvim " catppuccin-latte, catppuccin-frappe, catppuccin-macchiato, catppuccin-mocha

vim.cmd.colorscheme "catppuccin-nvim"

Configuration

There is no need to call setup if you don't want to change the default options and settings.

require("catppuccin").setup({
    flavour = "auto", -- latte, frappe, macchiato, mocha
    background = { -- :h background
        light = "latte",
        dark = "mocha",
    },
    transparent_background = false, -- disables setting the background color.
    float = {
        transparent = false, -- enable transparent floating windows
        solid = false, -- use solid styling for floating windows, see |winborder|
    },
    term_colors = false, -- sets terminal colors (e.g. `g:terminal_color_0`)
    dim_inactive = {
        enabled = false, -- dims the background color of inactive window
        shade = "dark",
        percentage = 0.15, -- percentage of the shade to apply to the inactive window
    },
    no_italic = false, -- Force no italic
    no_bold = false, -- Force no bold
    no_underline = false, -- Force no underline
    styles = { -- Handles the styles of general hi groups (see `:h highlight-args`):
        comments = { "italic" }, -- Change the style of comments
        conditionals = { "italic" },
        loops = {},
        functions = {},
        keywords = {},
        strings = {},
        variables = {},
        numbers = {},
        booleans = {},
        properties = {},
        types = {},
        operators = {},
        -- miscs = {}, -- Uncomment to turn off hard-coded styles
    },
    lsp_styles = { -- Handles the style of specific lsp hl groups (see `:h lsp-highlight`).
        virtual_text = {
            errors = { "italic" },
            hints = { "italic" },
            warnings = { "italic" },
            information = { "italic" },
            ok = { "italic" },
        },
        underlines = {
            errors = { "underline" },
            hints = { "underline" },
            warnings = { "underline" },
            information = { "underline" },
            ok = { "underline" },
        },
        inlay_hints = {
            background = true,
        },
    },
    color_overrides = {},
    custom_highlights = {},
    default_integrations = true,
    auto_integrations = false,
    integrations = {
        cmp = true,
        gitsigns = true,
        nvimtree = true,
        notify = false,
        mini = {
            enabled = true,
            indentscope_color = "",
        },
        -- For more plugins integrations please scroll down (https://github.com/catppuccin/nvim#integrations)
    },
})

-- setup must be called before loading
vim.cmd.colorscheme "catppuccin-nvim"

Customization

Getting colors

local latte = require("catppuccin.palettes").get_palette "latte"
local frappe = require("catppuccin.palettes").get_palette "frappe"
local macchiato = require("catppuccin.palettes").get_palette "macchiato"
local mocha = require("catppuccin.palettes").get_palette "mocha"

Returns a table where the key is the name of the color and the value is the hex code.

Overwriting colors

Colors can be overwritten using color_overrides, see https://github.com/catppuccin/nvim/discussions/323 for inspiration:

require("catppuccin").setup {
    color_overrides = {
        all = {
            text = "#ffffff",
        },
        latte = {
            base = "#ff0000",
            mantle = "#242424",
            crust = "#474747",
        },
        frappe = {},
        macchiato = {},
        mocha = {},
    }
}

Overwriting highlight groups

Global highlight groups can be overwritten, for example:

require("catppuccin").setup {
    custom_highlights = function(colors)
        return {
            Comment = { fg = colors.flamingo },
            TabLineSel = { bg = colors.pink },
            CmpBorder = { fg = colors.surface2 },
            Pmenu = { bg = colors.none },
        }
    end
}

Highlight groups per flavour can also be overwritten, for example:

require("catppuccin").setup {
    highlight_overrides = {
        all = function(colors)
            return {
                NvimTreeNormal = { fg = colors.none },
                CmpBorder = { fg = "#3e4145" },
            }
        end,
        latte = function(latte)
            return {
                Normal = { fg = latte.base },
            }
        end,
        frappe = function(frappe)
            return {
                ["@comment"] = { fg = frappe.surface2, style = { "italic" } },
            }
        end,
        macchiato = function(macchiato)
            return {
                LineNr = { fg = macchiato.overlay1 },
            }
        end,
        mocha = function(mocha)
            return {
                Comment = { fg = mocha.flamingo },
            }
        end,
    },
}

Integrations

Catppuccin provides theme support for other plugins in the Neovim ecosystem and extended Neovim functionality through integrations.

To enable/disable an integration you just need to set it to true/false, for example:

require("catppuccin").setup({
    integrations = {
        cmp = true,
        gitsigns = true,
        nvimtree = true,
        notify = false,
        mini = {
            enabled = true,
            indentscope_color = "",
        },
    }
})

Some integrations are enabled by default, you can control this behaviour with default_integrations option.

require("catppuccin").setup({
    default_integrations = false,
})

If you use lazy.nvim as your package manager, you can use the auto_integrations option to let catppuccin automatically detect installed plugins and enable their respective integrations.

require("catppuccin").setup({
    auto_integrations = true,
})

Below is a list of supported plugins and their corresponding integration module.

Important

If you'd like to see the full list of highlight groups modified by Catppuccin, see the lua/catppuccin/groups/integrations/ directory.

Plugin	Default
aerial.nvim	`aerial = false`
alpha-nvim	`alpha = true`
artio.nvim	`artio = true`
barbar.nvim	`barbar = false`
barbecue.nvim	`barbecue = { dim_dirname = true, -- directory name is dimmed by default bold_basename = true, dim_context = false, alt_background = false, },` Special Use this to set it up: `require("barbecue").setup { theme = "catppuccin-nvim", -- catppuccin-latte, catppuccin-frappe, catppuccin-macchiato, catppuccin-mocha }`
beacon.nvim	`beacon = false`
blink.cmp	`blink_cmp = { style = 'bordered', }`
blink.indent	`blink_indent = true`
blink.pairs	`blink_pairs = true` Special Use this to set it up: `require("blink.pairs").setup { highlights = { groups = { "BlinkPairsRed", "BlinkPairsYellow", "BlinkPairsBlue", "BlinkPairsOrange", "BlinkPairsGreen", "BlinkPairsPurple", "BlinkPairsCyan", }, }, }`
bufferline.nvim	Special Update your bufferline config to use the Catppuccin components: Note bufferline needs to be loaded after setting up Catppuccin or it will highlight incorrectly `use "akinsho/bufferline.nvim" { after = "catppuccin", config = function() require("bufferline").setup { highlights = require("catppuccin.special.bufferline").get_theme() } end }` Configurations are self-explanatory, see `:h bufferline-highlights` for detailed explanations: `local mocha = require("catppuccin.palettes").get_palette "mocha" bufferline.setup { highlights = require("catppuccin.special.bufferline").get_theme { styles = { "italic", "bold" }, custom = { all = { fill = { bg = "#000000" }, }, mocha = { background = { fg = mocha.text }, }, latte = { background = { fg = "#000000" }, }, }, }, }`
buffon.nvim	`buffon = false`
coc.nvim	`coc_nvim = false` Special Setting `enabled` to `true` enables this integration. `coc_nvim = true,` Note coc.nvim by default link to native lsp highlight groups so `lsp_styles` options will also apply to coc In the nested tables you can set the style for the diagnostics, both `virtual_text` (what you see on the side) and `underlines` (what points directly at the thing (e.g. an error)). `lsp_styles = { virtual_text = { errors = { "italic" }, hints = { "italic" }, warnings = { "italic" }, information = { "italic" }, ok = { "italic" }, }, underlines = { errors = { "underline" }, hints = { "underline" }, warnings = { "underline" }, information = { "underline" }, ok = { "underline" }, }, inlay_hints = { background = true, }, },`
colorful-winsep.nvim	`colorful_winsep = { enabled = false, color = "red", }`
dashboard-nvim	`dashboard = true`
diffview.nvim	`diffview = false`
dropbar.nvim	`dropbar = { enabled = false, color_mode = false, -- enable color for kind's texts, not just kind's icons },`
feline.nvim	Special Update your Feline config to use the Catppuccin components: `local ctp_feline = require('catppuccin.special.feline') ctp_feline.setup() require("feline").setup({ components = ctp_feline.get_statusline(), })` Notice that calling `setup()` is optional. You may pass a lua table in order to change assets, settings and the colors per vim mode. Here are the defaults: local clrs = require("catppuccin.palettes").get_palette() local ctp_feline = require('catppuccin.special.feline') local U = require "catppuccin.utils.colors" ctp_feline.setup({ assets = { left_separator = "", right_separator = "", mode_icon = "", dir = "󰉖", file = "󰈙", lsp = { server = "󰅡", error = "", warning = "", info = "", hint = "", }, git = { branch = "", added = "", changed = "", removed = "", }, }, sett = { text = U.vary_color({ latte = latte.base }, clrs.surface0), bkg = U.vary_color({ latte = latte.crust }, clrs.surface0), diffs = clrs.mauve, extras = clrs.overlay1, curr_file = clrs.maroon, curr_dir = clrs.flamingo, show_modified = false, -- show if the file has been modified show_lazy_updates = false -- show the count of updatable plugins from lazy.nvim -- need to set checker.enabled = true in lazy.nvim first -- the icon is set in ui.icons.plugin in lazy.nvim }, mode_colors = { ["n"] = { "NORMAL", clrs.lavender }, ["no"] = { "N-PENDING", clrs.lavender }, ["i"] = { "INSERT", clrs.green }, ["ic"] = { "INSERT", clrs.green }, ["t"] = { "TERMINAL", clrs.green }, ["v"] = { "VISUAL", clrs.flamingo }, ["V"] = { "V-LINE", clrs.flamingo }, [""] = { "V-BLOCK", clrs.flamingo }, ["R"] = { "REPLACE", clrs.maroon }, ["Rv"] = { "V-REPLACE", clrs.maroon }, ["s"] = { "SELECT", clrs.maroon }, ["S"] = { "S-LINE", clrs.maroon }, [""] = { "S-BLOCK", clrs.maroon }, ["c"] = { "COMMAND", clrs.peach }, ["cv"] = { "COMMAND", clrs.peach }, ["ce"] = { "COMMAND", clrs.peach }, ["r"] = { "PROMPT", clrs.teal }, ["rm"] = { "MORE", clrs.teal }, ["r?"] = { "CONFIRM", clrs.mauve }, ["!"] = { "SHELL", clrs.green }, }, view = { lsp = { progress = true, -- if true the status bar will display an lsp progress indicator name = false, -- if true the status bar will display the lsp servers name, otherwise it will display the text "Lsp" exclude_lsp_names = {}, -- lsp server names that should not be displayed when name is set to true separator = "\|", -- the separator used when there are multiple lsp servers }, } }) Warning Currently feline doesn't officially support custom themes. In order for `:colorscheme catppuccin-<flavour>` to work you could add this autocmd as a workaround: `vim.api.nvim_create_autocmd("ColorScheme", { pattern = "*", callback = function() package.loaded["feline"] = nil package.loaded["catppuccin.special.feline"] = nil require("feline").setup { components = require("catppuccin.special.feline").get_statusline(), } end, })`
fern.vim	`fern = false`
fidget.nvim	`fidget = false` Special Set `notification.window.winblend` to `0`: `require("fidget").setup { notification = { window = { winblend = 0, }, } -- ... the rest of your fidget config }`
flash.nvim	`flash = true`
fzf-lua	`fzf = true`
gitgraph.nvim	`gitgraph = false`
gitsigns.nvim	`gitsigns = true` Special `gitsigns = { enabled = true, -- align with the transparent_background option by default transparent = false, }`
grug-far.nvim	`grug_far = false`
harpoon	`harpoon = false`
headlines.nvim	`headlines = false`
hop.nvim	`hop = false`
indent-blankline.nvim	indent_blankline = { enabled = true, scope_color = "", -- catppuccin color (eg. `lavender`) Default: text colored_indent_levels = false, }, Special `colored_indent_levels` enables char highlights per indent level. Follow the instructions here to set the latter up.
leap.nvim	`leap = false`
lightline.vim	Special `let g:lightline = {'colorscheme': 'catppuccin'}`
lightspeed.nvim	`lightspeed = false`
lir.nvim	`lir = { enabled = false, git_status = false }`
lspsaga.nvim	`lsp_saga = false` Special For custom Lsp Kind Icon and Color `require("lspsaga").setup { ui = { kind = require("catppuccin.groups.integrations.lsp_saga").custom_kind(), }, }`
lualine.nvim	-- transparent_bg = opts.transparent_background and "NONE" or C.mantle lualine = { normal = { a = { bg = C.blue, fg = C.mantle, gui = "bold" }, b = { bg = C.surface0, fg = C.blue }, c = { bg = transparent_bg, fg = C.text }, }, insert = { a = { bg = C.green, fg = C.base, gui = "bold" }, b = { bg = C.surface0, fg = C.green }, }, terminal = { a = { bg = C.green, fg = C.base, gui = "bold" }, b = { bg = C.surface0, fg = C.green }, }, command = { a = { bg = C.peach, fg = C.base, gui = "bold" }, b = { bg = C.surface0, fg = C.peach }, }, visual = { a = { bg = C.mauve, fg = C.base, gui = "bold" }, b = { bg = C.surface0, fg = C.mauve }, }, replace = { a = { bg = C.red, fg = C.base, gui = "bold" }, b = { bg = C.surface0, fg = C.red }, }, inactive = { a = { bg = transparent_bg, fg = C.blue }, b = { bg = transparent_bg, fg = C.surface1, gui = "bold" }, c = { bg = transparent_bg, fg = C.overlay0 }, }, }, Special To implement color overrides in the `integrations.lualine` spec: -- In your catppuccin config (integrations): lualine = { -- lualine color overrides in the following hierarchy: Catppuccin Flavor -> Mode -> Lualine Section -- The Catppuccin flavor entry can be any Catpuccin flavor or "all" to apply to all flavors -- The flavor entry can be either a table or a function which consumes the current Catppuccin palette, just like custom_highlights and color_overrides all = function(colors) ---@type CtpIntegrationLualineOverride return { -- Specifying a normal-mode status line override for section a's background and b's foreground to use lavender like the main Catppuccin theme normal = { a = { bg = colors.lavender, gui = "italic" }, b = { fg = colors.lavender }, } } end, -- A macchiato-specific override, which takes priority over 'all'. Also using the direct table syntax instead of function in case you do not rely on dynamic palette colors macchiato = { normal = { a = { bg = "#abcdef" }, } }, }, -- And in your lualine config: require('lualine').setup { options = { -- lualine will integrate with catppuccin by name or automatically via `vim.g.colors_name` by setting this to "auto" theme = "catppuccin-nvim" -- ... the rest of your lualine config } }
markview.nvim	`markview = false`
mason.nvim	`mason = false`
mini.nvim	mini = { enabled = true, indentscope_color = "", -- catppuccin color (eg. `lavender`) Default: text },
neo-tree.nvim	`neotree = true`
neogit	`neogit = true`
neotest	`neotest = false`
noice.nvim	`noice = false`
notifier.nvim	`notifier = false`
nvim-cmp	`cmp = true`
copilot.vim	`copilot_vim = false,`
nvim-dap	`dap = true` Special `local sign = vim.fn.sign_define sign("DapBreakpoint", { text = "●", texthl = "DapBreakpoint", linehl = "", numhl = ""}) sign("DapBreakpointCondition", { text = "●", texthl = "DapBreakpointCondition", linehl = "", numhl = ""}) sign("DapLogPoint", { text = "◆", texthl = "DapLogPoint", linehl = "", numhl = ""})`
nvim-dap-ui	`dap_ui = true`
navic	`navic = { enabled = false, custom_bg = "NONE", -- "lualine" will set background to mantle },` Special `-- You NEED to enable highlight in nvim-navic setting or it won't work require("nvim-navic").setup { highlight = true }`
nvim-notify	`notify = false`
nvim-surround	`nvim_surround = false`
nvim-tree.lua	`nvimtree = true`
nvim-treesitter-context	`treesitter_context = true`
nvim-ts-rainbow2	`ts_rainbow2 = false`
nvim-ts-rainbow	`ts_rainbow = false`
nvim-ufo	`ufo = true`
nvim-window-picker	`window_picker = false`
octo.nvim	`octo = false`
overseer.nvim	`overseer = false`
pounce.nvim	`pounce = false`
rainbow-delimiters.nvim	`rainbow_delimiters = true`
reactive.nvim	Special There're 2 available presets (`cursor` and `cursorline`) for every flavour. Here is how you can use them. `require('reactive').setup { load = { 'catppuccin-mocha-cursor', 'catppuccin-mocha-cursorline' } }` To use another flavour just replace `mocha` with the one you want to use.
render-markdown.nvim	`render_markdown = true`
snacks.nvim	snacks = { enabled = false, indent_scope_color = "", -- catppuccin color (eg. `lavender`) Default: overlay2 }
symbols-outline.nvim	Note This plugin has been archived by the author, consider using outline.nvim `symbols_outline = false`
telekasten.nvim	`telekasten = false`
telescope.nvim	`telescope = { enabled = true, }`
trouble.nvim	`lsp_trouble = false`
vim-airline	Special `let g:airline_theme = 'catppuccin'`
vim-clap	Special Use this to set it up: `let g:clap_theme = 'catppuccin'`
vim-dadbod-ui	`dadbod_ui = false`
vim-gitgutter	`gitgutter = false`
vim-illuminate	`illuminate = { enabled = true, lsp = false }`
vim-sandwich	`sandwich = false`
vim-signify	`signify = false`
vim-sneak	`vim_sneak = false`
vimwiki	`vimwiki = false`
which-key.nvim	`which_key = false`

Compile

Catppuccin is a highly customizable and configurable colorscheme. This does however come at the cost of complexity and execution time. Catppuccin can pre compute the results of your configuration and store the results in a compiled Lua file. We use these pre-cached values to set it's highlights.

By default, Catppuccin writes the compiled results into the system's cache directory. See below if you'd like to change the cache directory:

require("catppuccin").setup({ -- Note: On windows we replace `/` with `\` by default
    compile_path = vim.fn.stdpath "cache" .. "/catppuccin"
})

🙋 FAQ

Why do my Treesitter highlights look incorrect?

Please disable additional_vim_regex_highlighting:

require("nvim-treesitter.configs").setup {
    highlight = {
        enable = true,
        additional_vim_regex_highlighting = false
    },
}

Why aren't my colors the same as the previews?

Catppuccin requires that your terminal supports true color, meaning that your terminal can display the full range of 16 million colors.

Supported: iterm2 (macOS), kitty, wezterm, alacritty, see full list...
Unsupported: Terminal.app (macOS), Terminus, Terminology, see full list...

If you use tmux, make sure to enable true color support and italic font support. This will prevent issues raised in #415 and #428.

💝 Thanks to

Current Maintainer(s)

Previous Maintainer(s)

nickjvandyke/opencode.nvim

Integrate Neovim and OpenCode AI to stay in your flow.

opencode.nvim

https://github.com/user-attachments/assets/077daa78-d401-4b8b-98d1-9ba9f94c2330

✨ Features

Connect to any opencode, or provide an integrated instance
Share editor context (buffer, selection, diagnostics, etc.)
Input prompts with completions, highlights, and normal-mode support
Select prompts from a library and define your own
Execute commands
Monitor and respond to events
View, accept or reject, and reload edits
Interact with opencode via an in-process LSP
Vim-y — supports ranges and dot-repeat
Simple, sensible defaults to get you started quickly

📦 Setup

lazy.nvim

{
  "nickjvandyke/opencode.nvim",
  version = "*", -- Latest stable release
  dependencies = {
    {
      -- `snacks.nvim` integration is recommended, but optional
      ---@module "snacks" <- Loads `snacks.nvim` types for configuration intellisense
      "folke/snacks.nvim",
      optional = true,
      opts = {
        input = {}, -- Enhances `ask()`
        picker = { -- Enhances `select()`
          actions = {
            opencode_send = function(...) return require("opencode").snacks_picker_send(...) end,
          },
          win = {
            input = {
              keys = {
                ["<a-a>"] = { "opencode_send", mode = { "n", "i" } },
              },
            },
          },
        },
      },
    },
  },
  config = function()
    ---@type opencode.Opts
    vim.g.opencode_opts = {
      -- Your configuration, if any; goto definition on the type or field for details
    }

    vim.o.autoread = true -- Required for `opts.events.reload`

    -- Recommended/example keymaps
    vim.keymap.set({ "n", "x" }, "<C-a>", function() require("opencode").ask("@this: ", { submit = true }) end, { desc = "Ask opencode…" })
    vim.keymap.set({ "n", "x" }, "<C-x>", function() require("opencode").select() end,                          { desc = "Execute opencode action…" })
    vim.keymap.set({ "n", "t" }, "<C-.>", function() require("opencode").toggle() end,                          { desc = "Toggle opencode" })

    vim.keymap.set({ "n", "x" }, "go",  function() return require("opencode").operator("@this ") end,        { desc = "Add range to opencode", expr = true })
    vim.keymap.set("n",          "goo", function() return require("opencode").operator("@this ") .. "_" end, { desc = "Add line to opencode", expr = true })

    vim.keymap.set("n", "<S-C-u>", function() require("opencode").command("session.half.page.up") end,   { desc = "Scroll opencode up" })
    vim.keymap.set("n", "<S-C-d>", function() require("opencode").command("session.half.page.down") end, { desc = "Scroll opencode down" })

    -- You may want these if you use the opinionated `<C-a>` and `<C-x>` keymaps above — otherwise consider `<leader>o…` (and remove terminal mode from the `toggle` keymap)
    vim.keymap.set("n", "+", "<C-a>", { desc = "Increment under cursor", noremap = true })
    vim.keymap.set("n", "-", "<C-x>", { desc = "Decrement under cursor", noremap = true })
  end,
}

nixvim

programs.nixvim = {
  extraPlugins = [
    pkgs.vimPlugins.opencode-nvim
  ];
};

Tip

Run :checkhealth opencode after setup.

⚙️ Configuration

opencode.nvim provides a rich and reliable default experience — see all available options and their defaults here.

Contexts

opencode.nvim replaces placeholders in prompts with the corresponding context:

Placeholder	Context
`@this`	Operator range or visual selection if any, else cursor position
`@buffer`	Current buffer
`@buffers`	Open buffers
`@visible`	Visible text
`@diagnostics`	Current buffer diagnostics
`@quickfix`	Quickfix list
`@diff`	Git diff
`@marks`	Global marks
`@grapple`	grapple.nvim tags

Tip

opencode reads referenced files from disk — save your changes!

Prompts

Select or reference prompts to review, explain, and improve your code:

Name	Prompt
`diagnostics`	Explain `@diagnostics`
`diff`	Review the following git diff for correctness and readability: `@diff`
`document`	Add comments documenting `@this`
`explain`	Explain `@this` and its context
`fix`	Fix `@diagnostics`
`implement`	Implement `@this`
`optimize`	Optimize `@this` for performance and readability
`review`	Review `@this` for correctness and readability
`test`	Add tests for `@this`

Server

You can manually run opencodes however you like and opencode.nvim will find them!

Important

You must run opencode with the --port flag to expose its server.

If opencode.nvim can't find an existing opencode, it uses the configured server to start one for you, defaulting to an embedded terminal.

Keymaps

opencode.nvim sets these normal-mode keymaps in the embedded terminal for Neovim-like message navigation:

Keymap	Command	Description
`<C-u>`	`session.half.page.up`	Scroll up half page
`<C-d>`	`session.half.page.down`	Scroll down half page
`gg`	`session.first`	Go to first message
`G`	`session.last`	Go to last message
`<Esc>`	`session.interrupt`	Interrupt

Customization

Example using snacks.terminal instead:

local opencode_cmd = 'opencode --port'
---@type snacks.terminal.Opts
local snacks_terminal_opts = {
  win = {
    position = 'right',
    enter = false,
    on_win = function(win)
      -- Set up keymaps and cleanup for an arbitrary terminal
      require('opencode.terminal').setup(win.win)
    end,
  },
}
---@type opencode.Opts
vim.g.opencode_opts = {
  server = {
    start = function()
      require('snacks.terminal').open(opencode_cmd, snacks_terminal_opts)
    end,
    stop = function()
      require('snacks.terminal').get(opencode_cmd, snacks_terminal_opts):close()
    end,
    toggle = function()
      require('snacks.terminal').toggle(opencode_cmd, snacks_terminal_opts)
    end,
  },
}

🚀 Usage

Ask — `require("opencode").ask()`

Input a prompt for opencode.

Press <Up> to browse recent asks.
Highlights and completes contexts and opencode subagents.
- Press <Tab> to trigger built-in completion.
End the prompt with \n to append instead of submit.
Additionally, when using snacks.input:
- Press <S-CR> to append instead of submit.
- Offers completions via in-process LSP.

Select — `require("opencode").select()`

Select from all opencode.nvim functionality.

Prompts
Commands
Server controls

Highlights and previews items when using snacks.picker.

Prompt — `require("opencode").prompt()`

Prompt opencode.

Resolves named references to configured prompts.
Injects configured contexts.
opencode will interpret @ references to files or subagents.

Operator — `require("opencode").operator()`

Wraps prompt as an operator, supporting ranges and dot-repeat.

Command — `require("opencode").command()`

Command opencode:

Command	Description
`session.list`	List sessions
`session.new`	Start a new session
`session.select`	Select a session
`session.share`	Share the current session
`session.interrupt`	Interrupt the current session
`session.compact`	Compact the current session (reduce context size)
`session.page.up`	Scroll messages up by one page
`session.page.down`	Scroll messages down by one page
`session.half.page.up`	Scroll messages up by half a page
`session.half.page.down`	Scroll messages down by half a page
`session.first`	Jump to the first message in the session
`session.last`	Jump to the last message in the session
`session.undo`	Undo the last action in the current session
`session.redo`	Redo the last undone action in the current session
`prompt.submit`	Submit the TUI input
`prompt.clear`	Clear the TUI input
`agent.cycle`	Cycle the selected agent

LSP

Warning

This feature is experimental! Try it out with vim.g.opencode_opts.lsp.enabled = true.

opencode.nvim provides an in-process LSP to interact with opencode via the LSP functions you're used to!

LSP Function	`opencode.nvim` Handler
Hover	Asks `opencode` for a brief explanation of the symbol under the cursor
Code Actions	Asks `opencode` to explain or fix diagnostics under the cursor

👀 Events

opencode.nvim forwards opencode's Server-Sent-Events as an OpencodeEvent autocmd:

-- Handle `opencode` events
vim.api.nvim_create_autocmd("User", {
  pattern = "OpencodeEvent:*", -- Optionally filter event types
  callback = function(args)
    ---@type opencode.server.Event
    local event = args.data.event
    ---@type number
    local port = args.data.port

    -- See the available event types and their properties
    vim.notify(vim.inspect(event))
    -- Do something useful
    if event.type == "session.idle" then
      vim.notify("`opencode` finished responding")
    end
  end,
})

Edits

When opencode edits a file, opencode.nvim automatically reloads the corresponding buffer.

Permissions

When opencode requests a permission, opencode.nvim waits for idle to ask you to approve or deny it.

Edits

For edit requests, opencode.nvim opens the target file in a new tab and uses Neovim's :diffpatch to display the proposed changes side-by-side. See :h 'diffopt' for customization.

Keymap	Function
`da`	Accept the entire edit request
`dr`	Reject the entire edit request
`]c/[c`	Next/prev change
`dp`	Natively accept only the hunk under the cursor, and reject the edit request
`do`	Natively reject only the hunk under the cursor, and reject the edit request
`q`	Close the diff

Statusline

require("lualine").setup({
  sections = {
    lualine_z = {
      {
        require("opencode").statusline,
      },
    }
  }
})

🙏 Acknowledgments

Inspired by nvim-aider, neopencode.nvim, and sidekick.nvim.
Uses opencode's TUI for simplicity — see sudo-tee/opencode.nvim for a Neovim frontend.
mcp-neovim-server may better suit you, but it lacks customization and tool calls are slow and unreliable.

GitHub Lua Daily Trending

olimorris/codecompanion.nvim

💜 Sponsors

✨ Features

📸 In Action

The Chat Buffer

Tools + Agentic Workflows

Inline Interaction

🚀 Getting Started

🧰 Troubleshooting

🎁 Contributing

👏 Acknowledgements

folke/snacks.nvim

🍿 snacks.nvim

✨ Features

⚡️ Requirements

📦 Installation

lazy.nvim

⚙️ Configuration

🚀 Usage

🌈 Highlight Groups

coder/claudecode.nvim

claudecode.nvim

What Makes This Special

Installation

Requirements

Local Installation Configuration

What is a Local Installation?

Detecting Your Installation Type

Configuring for Local Installation

Installation Methods

Platform Support

Benefits

Configuring for Native Binary

Quick Demo

Usage

Key Commands

Working with Diffs

How It Works

Architecture

Advanced Configuration

Working Directory Control

Floating Window Configuration

Basic Floating Window with Ctrl+, Toggle

Terminal Providers

None (No-Op) Provider

External Terminal Provider

Custom Terminal Providers

Custom Provider Example

Community Extensions

🔍 claude-fzf.nvim

📚 claude-fzf-history.nvim

Auto-Save Plugin Issues

Troubleshooting

Contributing

License

Acknowledgements

LazyVim/starter

💤 LazyVim

GustavEikaas/easy-dotnet.nvim

Simplifying .NET development in Neovim

Motivation

Table of Contents

Features

Requirements

Setup

Without options

With options

Lualine config

Commands

Lua functions

Vim commands

Roslyn LSP

Test runner

Keymaps

Debugging tests

Running tests from buffer

Project view

Features

Keymaps

🍿 `snacks.nvim`