https://github.com/mathijs-bakker/godotdev.nvim
Neovim plugin for Godot. Use Neovim as external editor. Provides LSP support for GDScript and Godot shaders, DAP debugging, and Tree-sitter syntax highlighting.
https://github.com/mathijs-bakker/godotdev.nvim
csharp dap debugger gdscript gdshader godot lsp neovim toolkit
Last synced: 3 months ago
JSON representation
Neovim plugin for Godot. Use Neovim as external editor. Provides LSP support for GDScript and Godot shaders, DAP debugging, and Tree-sitter syntax highlighting.
- Host: GitHub
- URL: https://github.com/mathijs-bakker/godotdev.nvim
- Owner: Mathijs-Bakker
- License: apache-2.0
- Created: 2025-08-18T10:14:53.000Z (10 months ago)
- Default Branch: master
- Last Pushed: 2025-10-10T08:16:16.000Z (8 months ago)
- Last Synced: 2025-10-20T06:51:46.348Z (8 months ago)
- Topics: csharp, dap, debugger, gdscript, gdshader, godot, lsp, neovim, toolkit
- Language: Lua
- Homepage:
- Size: 312 KB
- Stars: 10
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- Contributing: CONTRIBUTING.md
- Funding: .github/FUNDING.yml
- License: LICENSE
Awesome Lists containing this project
README
# godotdev.nvim
**godotdev.nvim** is a batteries-included Neovim plugin for Godot 4.x game development.
It allows you to use Neovim as a fully featured external editor for Godot, with minimal setup.
This plugin provides:
- **LSP support** for GDScript and Godot shaders (`.gdshader` files)
- **Debugging** via `nvim-dap` for GDScript
- **Treesitter syntax highlighting** for Godot shader files
- **Automatic formatting** of `.gd` files using `gdformat`
- **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.
## Features
godotdev.nvim provides a complete Neovim environment for Godot 4.x development, with minimal setup. Key features include:
### LSP Support
- Full GDScript language support (Go to definition, references, hover, rename, code actions, etc.)
- `.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 [`gdtoolkit`](https://pypi.org/project/gdtoolkit/)
- Reloads buffer after formatting for immediate feedback
- Recommended `.editorconfig` included for consistent indentation (4 spaces per indent)
### Health Checks
- `:checkhealth godotdev` validates:
- Required dependencies: `nvim-lspconfig`, `nvim-dap`, `nvim-dap-ui`, `nvim-treesitter`
- Godot editor LSP and debug servers
- Optional C# tooling: `dotnet`, `csharp-ls`/OmniSharp, `netcoredbg`
- Formatter: `gdformat` (with installation instructions)
- Detects common issues like mixed indentation in GDScript/C# files
### Editor Integration
- Commands to start or reconnect to Godot’s editor LSP:
- `:GodotStartEditorServer`
- `:GodotReconnectLSP`
- 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-lspconfig`
- `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-lspconfig', 'nvim-dap', 'nvim-dap-ui', '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 `rn` to rename, `gd` to go to definition, `gr` for references, etc.
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
csharp = true, -- Enable C# Installation Support
autostart_editor_server = true, -- Enable auto start Nvim server
})
```
### 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
- `Editor Settings > Interface > Editor > Save on Focus Loss`
Show Screenshot -> Godot Editor Settings
- `Editor Settings > Interface > Editor > Import Resources When Unfocused`
Show Screenshot -> Godot Editor Settings
### Open .gdscript/.gdshader from Godot in Neovim
When you click on a gdscript in Godot's FileSystem dock it doesn't open automatically in Neovim.
A [workaround](doc/neovim-external-editor-setup.md) is to to create a small script which launches the file in Neovim.
#### >> macOS/Linux
Complete instructions [here](doc/neovim-external-editor-setup.md)
#### >> Windows
1. Set Neovim to listen on a TCP port
```bash
nvim --listen 127.0.0.1:6666
```
--listen works with host:port on Windows.
1. Tell Godot to connect to that port
In Godot, configure your external editor or plugin to connect to `127.0.0.1:6666`.
Make sure the TCP port you choose is free and consistent between Neovim and Godot.
## Godot editor server
You can manually start the Neovim editor server used by Godot:
```vim
:GodotStartEditorServer
```
Or automatically on plugin setup:
```lua
require("godotdev").setup({
autostart_editor_server = true,
})
```
This ensures Godot can communicate with Neovim as an external editor.
## Reconnect to Godot's LSP server
If the LSP disconnects or you opened a script before Neovim, run:
```vim
:GodotReconnectLSP
```
Reconnects **all Godot buffers** to the LSP.
## C# Installation Support
- Enable by setting `csharp = true` in `require("godotdev").setup()`
- C# LSP setup is user-managed; `:checkhealth godotdev` will only verify tooling is installed:
- .NET SDK (`dotnet`)
- C# LSP server (`csharp-ls` or `omnisharp`)
- Debugger (`netcoredbg`)
## Autoformatting / Indentation
Godot expects **spaces, 4 per indent** (for both GDScript and C#).
This plugin automatically sets buffer options for `.gd` files.
Additionally, `.gd` files are autoformatted on save with [`gdtoolkit`](https://github.com/godotengine/gdtoolkit):
```vim
:w
```
Make sure `gdformat` is installed and in your PATH. If not, you will see a warning notification.
For more info on indentation: `:help godotdev-indent`
## Hiding Godot Project Files in oil.nvim and mini.files
Godot generates files and folders like `.uid`, `.import`, or `.godot/` that can clutter your file explorer.
You can hide them in both [oil.nvim](https://github.com/stevearc/oil.nvim) and [mini.files](https://github.com/nvim-mini/mini.nvim
) by filtering against their patterns.
[Show me how](doc/hide-files-in-file-explorers.md)