[](https://buymeacoffee.com/mathijs.bakker)
[](https://buymeacoffee.com/mathijs.bakker)
[](https://github.com/Mathijs-Bakker/godotdev.nvim/actions/workflows/ci.yml)
# godotdev.nvim
A Neovim plugin for Godot 4 that brings GDScript/GDShader LSP, DAP debugging, and formatting to your external‑editor workflow.
**This plugin helps you to set up:**
- **LSP support** for GDScript and Godot shaders (`.gdshader` files)
- **Godot class docs** in Neovim, rendered from the official docs source as Markdown
- **Debugging** via `nvim-dap` for GDScript
- **Optional live run output** for `:GodotRun*` commands in a Neovim buffer or float
- **Treesitter syntax highlighting** for Godot shader files
- **Automatic formatting** of `.gd` files using `gdscript-formatter`
- **Optional C# support** (user-managed LSP, plus debugging and tooling checks)
- **Built-in health checks** to verify environment, dependencies, and editor integration
While it is possible to configure Neovim manually for Godot development, this plugin **simplifies setup** and ensures a consistent, cross-platform workflow. It automatically configures LSP, debugging, formatting, and environment checks, so you can focus on writing game code rather than troubleshooting editor setup.
| DAP debugging within Nvim |
Insert a node path directly from Godot in Nvim |
Access Godot's documentation in/from Nvim |
|
|
|
## Table of Contents
- [Why godotdev.nvim?](#why-godotdevnvim)
- [Features](#features)
- [Requirements](#requirements)
- [Installation (Lazy.nvim)](#installation-lazynvim)
- [Installation (`vim.pack`, Neovim 0.12+)](#installation-vimpack-neovim-012)
- [Quickstart](#quickstart)
- [Configuration](#configuration)
- [Testing](#testing)
- [Optimize Godot editor for Neovim](#optimize-godot-editor-for-neovim)
- [Open scripts from Godot Editor in Neovim (running in a terminal)](#open-scripts-from-godot-editor-in-neovim-running-in-a-terminal)
- [Godot editor server](#godot-editor-server)
- [Reconnect to Godot's LSP server](#reconnect-to-godots-lsp-server)
- [Run Godot](#run-godot)
- [Scene Tree](#scene-tree)
- [Godot class docs](#godot-class-docs)
- [C# Installation Support](#c-installation-support)
- [Autoformatting / Indentation](#autoformatting--indentation)
- [Recommended Godot addon (Node Copy)](#recommended-godot-addon-node-copy)
- [Hiding Godot Project Files in oil.nvim and mini.files](#hiding-godot-project-files-in-oilnvim-and-minifiles)
## Why godotdev.nvim?
- Turn Neovim into a first‑class external editor for Godot 4 projects.
- Get LSP features for GDScript/GDShader without manual wiring.
- Debug GDScript via DAP and validate setup with built‑in health checks.
## Features
Below is a quick overview of what you get out of the box:
### LSP Support
- Full GDScript language support (Go to definition, references, hover, rename, code actions, etc.)
- Optional inline hints via Neovim's built-in inlay hint API when the attached Godot LSP supports `textDocument/inlayHint`
- `.gdshader` syntax highlighting and language features via Treesitter
- Optional C# LSP support (user-managed `csharp-ls` or OmniSharp) for Godot projects with C# scripts
### Debugging (DAP)
- Debug GDScript directly from Neovim using `nvim-dap`
- Optional C# debugging via `netcoredbg`
### Formatting
- Automatic `.gd` file formatting using `gdscript-formatter`
- Reloads buffer after formatting for immediate feedback
- Recommended `.editorconfig` included for consistent indentation (4 spaces per indent)
- Supported formatters:
- [`gdscript-formatter`](https://github.com/GDQuest/GDScript-formatter) (default)
- [`gdformat`](https://github.com/Scony/godot-gdscript-toolkit) (alternative)
### Health Checks
- `:checkhealth godotdev` validates:
- Built-in Neovim LSP support plus plugin dependencies: `nvim-dap`, `nvim-dap-ui`, `nvim-treesitter`
- Godot editor LSP and debug servers
- Floating Godot docs support (`curl` and active docs source configuration)
- Optional C# tooling: `dotnet`, `csharp-ls`/OmniSharp, `netcoredbg`
- Formatter: `gdscript-formatter` by default, with `gdformat` as an alternative
### Editor Integration
- Commands to start or reconnect to Godot’s editor LSP:
- `:GodotStartEditorServer`
- `:GodotReconnectLSP`
- `:GodotToggleInlineHints`
- Commands to run Godot from Neovim without DAP:
- `:GodotRunProject`
- `:GodotRunCurrentScene`
- `:GodotRunScene {path}`
- `:GodotRunScenePicker` (optional Telescope integration)
- Commands to inspect a static scene tree in Neovim:
- `:GodotSceneTree [path]`
- `:GodotSceneTreeRefresh`
- Commands to open Godot class reference docs:
- `:GodotDocs [ClassName]`
- `:GodotDocsFloat [ClassName]`
- `:GodotDocsBuffer [ClassName]`
- `:GodotDocsBrowser [ClassName]`
- `:GodotDocsCursor`
- Automatic LSP attachment for Godot filetypes (`.gd`, `.gdshader`, `.gdresource`, optional `.cs`)
- Works cross-platform (macOS, Linux, Windows) with TCP or named pipes
### Optional C# Support
- Enable by setting `csharp = true` in `require("godotdev").setup()`
- C# LSP is configured by you (the plugin only checks that `csharp-ls` or OmniSharp is installed)
- Health checks and DAP integration included
## Requirements
- Neovim 0.11+
- Godot 4.x+ with TCP LSP enabled
- `nvim-dap` and `nvim-dap-ui` for debugging
- `nvim-treesitter`
- Windows users must have [`ncat`](https://nmap.org/ncat/) in PATH
- Optional C# support requires (you manage the LSP configuration):
- .NET SDK (dotnet)
- C# LSP server (csharp-ls recommended or omnisharp)
- netcoredbg debugger
## Installation (Lazy.nvim)
```lua
{
'Mathijs-Bakker/godotdev.nvim',
dependencies = { 'nvim-dap', 'nvim-dap-ui', 'nvim-treesitter' },
}
```
## Installation (`vim.pack`, Neovim 0.12+)
```lua
vim.pack.add({
"https://github.com/Mathijs-Bakker/godotdev.nvim",
"https://github.com/mfussenegger/nvim-dap",
"https://github.com/rcarriga/nvim-dap-ui",
"https://github.com/nvim-treesitter/nvim-treesitter",
})
```
## Quickstart
1. Open your Godot project in Neovim
1. Start Godot editor with TCP LSP enabled (Editor Settings → Network → Enable TCP LSP server)
1. Open a `.gd` or `.gdshader` file
1. LSP will automatically attach
1. Use Neovim's built-in LSP mappings such as `K`, `grr`, `grn`, and `gri`, or your own custom mappings
1. Start debugging with DAP (Launch scene configuration)
1. Optional: Enable C# support by setting `csharp = true` in the plugin setup
1. Run `:checkhealth godotdev` at any time to verify plugin, LSP, debug server, and C# dependencies
## Configuration
### Optional settings
```lua
require("godotdev").setup({
editor_host = "127.0.0.1", -- Godot editor host
editor_port = 6005, -- Godot LSP port
debug_port = 6006, -- Godot debugger port
godot_path = "godot", -- executable used by :GodotRun* and health checks
csharp = true, -- Enable C# Installation Support
autostart_editor_server = false, -- opt-in: start a Neovim server automatically on setup
formatter = "gdscript-formatter", -- "gdscript-formatter" | "gdformat" | false
formatter_cmd = nil, -- string or argv list; default gdscript-formatter adds "--reorder-code"
inline_hints = {
enabled = false, -- enable Neovim inlay hints when the attached server supports them
},
run = {
console = {
enabled = false, -- capture :GodotRun* output in Neovim; these runs are no longer detached
renderer = "buffer", -- "buffer" | "float"
buffer = {
position = "bottom", -- "right" | "bottom" | "current"
size = 0.3,
},
float = {
width = 0.8,
height = 0.25,
border = "rounded",
},
},
},
scene_tree = {
buffer = {
position = "left", -- "left" | "right"
size = 0.35,
},
icons = "nerdfont", -- "nerdfont" | "ascii" | false | { generic = "...", script_suffix = "...", types = { Node2D = "..." } }
icon_colors = {
generic = { fg = "white" },
groups = {
White = { fg = "white" },
Grey = { fg = "grey" },
Blue = { fg = "blue" },
Red = { fg = "red" },
Green = { fg = "green" },
Purple = { fg = "magenta" },
Yellow = { fg = "gold" },
},
},
},
editor_server = {
address = nil, -- nil uses the current server or the platform default
remove_stale_socket = true,
},
treesitter = {
auto_setup = true, -- convenience default; disable if you manage nvim-treesitter yourself
ensure_installed = { "gdscript" },
},
docs = {
renderer = "float", -- default: open docs in a floating window
fallback_renderer = "browser", -- nil | "browser" | "buffer"; browser is the only fetch-recovery fallback
missing_symbol_feedback = "message", -- "message" | "notify"
version = "stable", -- e.g. "stable", "latest", "4.5"
language = "en",
source_ref = "master", -- godot-docs git ref used for floating docs
source_base_url = nil, -- optional override for raw docs source
timeout_ms = 10000,
cache = {
enabled = true,
max_entries = 64,
},
float = {
width = 0.8,
height = 0.8,
border = "rounded",
},
buffer = {
position = "right", -- "right" | "bottom" | "current"
size = 0.4,
},
},
})
```
For formatter commands with flags, prefer an argv list:
```lua
formatter_cmd = { "gdscript-formatter", "--check" }
```
By default, `gdscript-formatter` runs with:
```lua
formatter_cmd = { "gdscript-formatter", "--reorder-code" }
```
To disable autoformat-on-save entirely:
```lua
formatter = false
```
If you already manage `nvim-treesitter` yourself, you can disable plugin-managed setup:
```lua
treesitter = {
auto_setup = false,
}
```
Default notes:
- `autostart_editor_server = false` is the safer default because starting a Neovim server is an external-editor concern and should be opt-in.
- `inline_hints.enabled = false` is the safer default because Godot's LSP support for inlay hints may vary by version and filetype.
- `run.console.enabled = false` is the safer default because live console capture changes `:GodotRun*` from detached launches to attached subprocesses managed by Neovim.
- `treesitter.auto_setup = true` stays enabled by default for convenience, but it is safe to turn off if you already configure `nvim-treesitter` yourself.
- `docs.fallback_renderer = "browser"` remains the default because browser fallback is the only option that can recover when rendered `.rst` docs cannot be fetched.
- The plugin uses Neovim's built-in LSP APIs; `nvim-lspconfig` is not required unless you want it for other servers in your own config.
If you enable inline hints, the plugin only turns them on automatically for buffers attached through this plugin's Godot GDScript LSP setup, and only when that client reports support for `textDocument/inlayHint`. If the current Godot GDScript LSP build does not advertise that method, no hints will appear even when `inline_hints.enabled = true`. C# LSP is user-managed in this plugin, so inline hints are not auto-enabled for C# buffers here. You can toggle the current buffer manually with `:GodotToggleInlineHints`.
**Note:** This plugin does not define any keymaps by default, so it will not interfere with the standard DAP mappings. If you want custom keybindings, you can configure them yourself. For example, you could map `:GDebug` to `DapNew` to start one or more new debug sessions.
See `:help dap-mappings` and `:help dap-user-commands` for more details.
Additional references:
- [DAP documentation](https://github.com/mfussenegger/nvim-dap/blob/master/doc/dap.txt)
- [DAP README / usage](https://github.com/mfussenegger/nvim-dap/tree/master?tab=readme-ov-file#usage)
## Testing
Run the headless test suite:
```bash
nvim --headless -u NONE -i NONE -c "lua dofile('tests/run.lua')" -c qa
```
The same command runs in GitHub Actions on pushes to `master` and on pull requests.
For integration testing, also run the plugin inside Neovim against a real Godot project and verify editor server, docs, formatting, and debugging flows on your target platform.
## Optimize Godot editor for Neovim
Below are the recommended settings for configuring the Godot editor for optimal integration with Neovim as your external editor. To access these settings, make sure that the **Advanced Settings switch is enabled** at the top of the **Editor Settings dialog**.
- `Editor Settings > Text Editor > Behavior > Auto Reload Scripts on External Change`
Show Screenshot -> Godot Editor Settings
Show Screenshot -> Godot Editor Settings
Show Screenshot -> Godot Editor Settings
