Devlog

Simple Neovim config

2024-09-12T00:00:00+00:00

Can I offer you a nice Neovim configuration in this trying time?

40 lines of code. That's all you need to have a solid starting point. Believe it or not, even those IDE-like features people talk about online can be enabled using just 1 plugin and a few keymaps.

You can try this simple config</a> and then add new things to it based on the problems you encounter along the way. Or just take this as an opportunity to learn about the basics of Neovim configuration.

Installing Neovim</h2>
We are going to need Neovim v0.9 or greater. But be aware a lot of plugins written in lua only guarantee support for the latest stable version. Right now that's v0.12 which was released on March 29, 2026</code>.
If you are on linux, pay attention to the version your package manager has available.
If you know how to install precompiled executables you can download the latest version from the github releases</a>.
There is also a Neovim version manager called bob</code>. You can try it: MordechaiHadad/bob</a>
The config file</h2> The entry point for our Neovim configuration will be a file called init.lua</code>. The location of this file can change depending on the operating system, so to save ourselves some trouble we will create it using Neovim in headless mode. Execute this command on the terminal. nvim --headless -c 'exe "write ++p" stdpath("config") . "/init.lua"' -c 'quit'</code></pre> Once the configuration file exists we can check where it is using this command in the terminal: nvim --headless -c 'echo $MYVIMRC' -c 'quit'</code></pre> Now we can start adding some code. But first, if you are not familiar with lua I suggest taking some time to understand the syntax of the language. Lua crash course (12 min video)</a></li> Learn X in Y minutes: Where X = lua</a></li> </ul> There is no need to memorize everything or become a lua expert, just review the syntax and have a reference at hand. Editor settings</h2> Neovim's defaults are actually good but there are still a few options that need to be enabled/changed. To do this in lua vim.o</a> is the recommended method</a>. We access a property through vim.o</code> and assign a value to it. Like this. vim.o.option_name = value</code></pre> Where option_name</code> can be anything on this list: Quickref - option list</a>. Here's some basic settings that you may find useful: Enable line numbers.</li> </ul> vim.o.number = true</code></pre> Disable line wrapping</li> </ul> vim.o.wrap = false</code></pre> Adjust the width of the tab character.</li> </ul> vim.o.tabstop = 2 vim.o.shiftwidth = 2</code></pre> Ignore case when the search pattern is all lowercase</li> </ul> vim.o.smartcase = true vim.o.ignorecase = true</code></pre> Clear search highlights after submit</li> </ul> vim.o.hlsearch = false</code></pre> Reserve a space in the gutter for signs. Some plugins use this to show icons.</li> </ul> vim.o.signcolumn = 'yes'</code></pre>Changing Neovim's theme</h2> The way we do this in lua is using vim.cmd</a>. Use vim.cmd</code> to execute the command colorscheme</code>. Ideally, we would do something like this. vim.cmd.colorscheme('retrobox')</code></pre> There is nothing wrong with the example above. That is the correct way to change the theme. However, retrobox</code> is a recent a addition to Neovim. If you have Neovim v0.9.5 or lower the command will fail. For the sake of backwards compatibility I will recommend using a "protective call," this way you can setup a backup theme just in case. local ok_theme = pcall(vim.cmd.colorscheme, 'retrobox') if not ok_theme then vim.cmd.colorscheme('habamax') end</code></pre>Clipboard interaction</h2> This is where we learn about vim.keymap.set()</a>, the function we use to create new keymaps. By default when you copy some text using the y</code> keymap Neovim will store that in a register. The p</code> keymap, which we use to paste, also uses the same register as y</code>. Basically, Neovim will ignore the system clipboard. We can still use it but we have to be explicit. Now, I like to keep the default behavior and what I do is create new keymaps to use the system clipboard. vim.keymap.set({'n', 'x'}, 'gy', '"+y', {desc = 'Copy to clipboard'}) vim.keymap.set({'n', 'x'}, 'gp', '"+p', {desc = 'Paste clipboard text'})</code></pre> With this gy</code> will be the keymap to copy content to the clipboard, and gp</code> will paste content from the clipboard to Neovim. Side note: {'n', 'x'}</code> is the list of vim modes where we want our keymap to be created. n</code> is normal mode and x</code> is visual mode. The leader key</h2> Usually we don't go around making keymaps that override the defaults like we did in the previous section. Most of the time we prefix our custom keymaps with the special string <leader></code>. This way we don't override an important feature or cause some sort of conflict. But what's <leader></code>? By default is the \</code> key. So, if we create a keymap like this: vim.keymap.set('n', '<leader>h', '<cmd>echo "hello there"<cr>')</code></pre> Then \ + h</code> will print the message hello there</code>. But we can change that using the vim global variable mapleader</code>. vim.g.mapleader = ','</code></pre> With this your leader key will change from \</code> to ,</code>. But note that if you want to use a special sequence like Control + k</code> you'll have to use its keycode. vim.g.mapleader = vim.keycode('<C-k>')</code></pre> Most people use the Space key</code> as their leader key. vim.g.mapleader = ' '</code></pre> Yes, that's a string with a blank space. vim.keycode</code> was added in Neovim v0.10, so before that people just did that thing with the blank space. So if you have it, then you can make it more explicit. vim.g.mapleader = vim.keycode('<Space>')</code></pre> Is important to note order matters, you must to define mapleader</code> before you use <leader></code> in your keymaps. Command shorcuts</h2> Now let's make keymaps that can execute Ex-commands</a>. There are two ways of doing it, and this is my favorite: <cmd>...<cr></code></pre> <cmd></code> is a special sequence that tells Neovim that you want to execute a vim expression. <cr></code> represents the enter key, it marks the end of the expression you want to execute. Here are a couple of examples: Save current file.</li> </ul> vim.keymap.set('n', '<leader>w', '<cmd>write<cr>', {desc = 'Save file'})</code></pre> Close all files and exit Neovim.</li> </ul> vim.keymap.set('n', '<leader>q', '<cmd>quitall<cr>', {desc = 'Exit vim'})</code></pre>Installing plugins</h2> There is a new feature called vim.pack</a>. This is a fully functional plugin manager built into Neovim. But only those who have access to Neovim v0.12 can use it. If you are one of the lucky ones you can learn more about it here: A guide to vim.pack</a>. Because I aim for backwards compatibility with Neovim v0.9.5</code> I will show you how to use mini.deps</a>. Is worth noting vim.pack</code>'s design was based on mini.deps</code>, so it should be fairly easy to migrate from one to the other. Now the question is, how does one install a plugin without a plugin manager? For this we are going to use Vim packages</a>. Long story short, we can put plugins in a specific location in they should work. Let's use Neovim in headless mode again, this time to create the directory were mini.deps</code> should be. nvim --headless -c 'call mkdir(stdpath("data") . "/site/pack/deps/start/", "p")' -c 'quit'</code></pre> This other command will show the full path of the directory we just created. nvim --headless -c 'echo stdpath("data") . "/site/pack/deps/start/"' -c 'quit'</code></pre> Now navigate to that location using your terminal. You will want to execute the command git clone</code> inside that directory. Install mini.nvim</a></li> </ul> mini.deps</code> is part of a project called mini.nvim</code>, which is a collection of lua modules aimed to solve common problems and enhance some of Neovim builtin features. So we want to download mini.nvim</code> using this command. git clone --filter=blob:none https://github.com/nvim-mini/mini.nvim</code></pre> If you are using Neovim v0.9 make sure to pin to the commit 3923662</a> since that's the last version that supports v0.9. git switch --detach 3923662bf3d6ca49a9503f8d7196ea0450983e6a</code></pre> After the install is complete we should generate the help tags. nvim --headless -c 'helptags ALL' -c 'quit'</code></pre> To use the plugin we must load the module mini.deps</code>. But here we want to use in a way that is "safe." Because what if we copy our configuration to a new machine but we forget to download mini.nvim</code>? If we do it the normal way we get hit by a scary wall of red text. We can make the experience less jarring by adding a few lines code. local ok, MiniDeps = pcall(require, 'mini.deps') if not ok then vim.notify('[WARN] mini.deps module not found', vim.log.levels.WARN) return end</code></pre> Here if something goes wrong Neovim will output a single line message then it will stop the execution of the script. If everything goes according to plan every function of the mini.deps</code> module will be inside the variable MiniDeps</code>. Is important to note all features of mini.nvim</code> are opt-in, meaning we have to do something in our configuration to enable a module. For mini.deps</code> we have to use a function called .setup()</code>. So we add this after we load the module. MiniDeps.setup({})</code></pre> Install nvim-lspconfig</a></li> </ul> We will use this plugin to help us enable IDE-like features. At this point we have mini.deps</code> available so is easier to install a new plugin. This is the minimum amount of code we need. MiniDeps.add('neovim/nvim-lspconfig')</code></pre> The .add()</code> function will make sure the plugin is installed and loaded. And is also the reason I recommend using mini.deps</code>. In Neovim v0.12 we can add new plugins like this: vim.pack.add({'https://github.com/neovim/nvim-lspconfig'})</code></pre> There are some sutle differences between mini.deps</code> and vim.pack</code> but for the most part those two functions do the same thing. The moment we need to add more information about the plugin we want to download we should replace the string with a lua table. For example, let's say we want to download a previous version of nvim-lspconfig</code>. This is what we do. MiniDeps.add({ source = 'neovim/nvim-lspconfig', checkout = 'v1.8.0' })</code></pre> With vim.pack</code> we do this: vim.pack.add({ { src = 'https://github.com/neovim/nvim-lspconfig', version = 'v1.8.0' }, })</code></pre> Note that vim.pack.add()</code> can install multiple plugins with a single function call. On the other hand MiniDeps.add()</code> can only install one plugin at a time. So to install multiple plugins with mini.deps</code> you execute MiniDeps.add()</code> as many times as needed. Now the first argument to MiniDeps.add()</code> is a lua table with some properties. source</code> would be the link to the plugin. In mini.deps</code> github links get a special treatment because is very popular, so here we can just specify the github user and the name of the repository. checkout</code> can be a commit hash, tag or branch name. In this case v1.8.0</a> is a tag on the nvim-lspconfig</code> repository, it is the last version that supports Neovim v0.9. To know more details about mini.deps</code> read the official documentation: mini.nvim/doc/mini-deps.html</a>. File explorer</h2> You should know that Neovim already has a file explorer, it's called netrw</a>. We are not going to use it here because it has a few quirks I dislike. Still, I think you should know it exists. Since we have mini.nvim</code> available let's use the file explorer it provides: mini.files</a>. First, we call mini.files</code> setup function. require('mini.files').setup({})</code></pre> This is a common convention of lua plugins. Sometimes you have to execute a function called .setup()</code> to enable the plugin. Notice I said is a convention, it is not a rule. Some plugins execute their setup automatically. How do we use mini.files</code>? We make a keymap to open the file explorer. vim.keymap.set('n', '<leader>e', '<cmd>lua MiniFiles.open()<cr>', {desc = 'File explorer'})</code></pre> After we open the file explorer press g</code> then ?</code>, this will show the keymaps available. What if we want to change the settings in mini.files</code>? Any custom setting should be inside the {}</code> of the setup function. Here's an example. require('mini.files').setup({ mappings = { show_help = 'gh', }, })</code></pre> This will change the keymap that shows the help window. Instead of g?</code> now is gh</code> (get help). These custom settings are in a "lua table." If there is piece of syntax that you should learn is that one. Knowing the correct syntax of a lua table will prevent so many headaches. And how did I know those settings exists? In Neovim's command-line I executed this command. :help mini.files</code></pre> That took me to the help page of mini.files</a>. Remember when we installed mini.nvim</code>? We generated some called help tags. These tags allow you to navigate to the "offline" documentation of the plugin: the help page. The tab complete feature of the :help</code> command is really good too. You can type :help mini</code> and then press the Tab</code> key, Neovim will show you all the help tags that start with mini</code>. One more thing, if the font on your terminal doesn't support "icons" then you can add the mini.icons</a> module. Set the style</code> property to ascii</code>. require('mini.icons').setup({style = 'ascii'})</code></pre>Navigating between files</h2> For educational purposes only, I will tell you what I do when I don't have plugins installed: I use the files</code> command to list the open files, then use the buffer</code> command to navigate the file I want. And to make it convenient I make a keymap. vim.keymap.set('n', '<leader><space>', '<cmd>files<cr>:buffer ', {desc = 'Search open files'})</code></pre> In the :buffer</code> command you can tab complete the name of the file or use the "id" of the buffer. But why do that when we have mini.nvim</code> installed? We can use the module mini.pick</a>. This one provides a fancy interactive filter. And it also gives us commands we can use to search files. If you use the module mini.extra</a> you will have access to more search commands in mini.pick</code>. Anyway, enable mini.pick</code> module. require('mini.pick').setup({})</code></pre> Then create keymaps to start the search between files. vim.keymap.set('n', '<leader><space>', '<cmd>Pick buffers<cr>', {desc = 'Search open files'}) vim.keymap.set('n', '<leader>ff', '<cmd>Pick files<cr>', {desc = 'Search all files'}) vim.keymap.set('n', '<leader>fh', '<cmd>Pick help<cr>', {desc = 'Search help tags'})</code></pre>Code completion</h2> For this we will use mini.completion</a> and mini.snippets</a>. require('mini.snippets').setup({}) require('mini.completion').setup({})</code></pre> mini.completion</code> is kind of a wrapper around Neovim's builtin completion mechanism. Neovim makes you press specific keybindings depending on the type of completion you want to get. And what mini.completion</code> can do is take that burden away from you, by triggering the completion automatically as you type. In other words, it adds true autocompletion to Neovim. By default you just get suggestions based on words of the current file. But whenever possible it'll try to use the LSP client to provide smart code completion. To control the completion menu we use Neovim's default keybindings: <Down></code>: Select the next item on the list. </li> <Up></code>: Select previous item on the list. </li> <Ctrl-n></code>: Select and insert text of the next item on the list. </li> <Ctrl-p></code>: Select and insert text of the previous item on the list. </li> <Ctrl-y></code>: Confirm selected item. </li> <Ctrl-e></code>: Cancel the completion. </li> <Enter></code>: If item was selected using <Up></code> or <Down></code> it confirms selection. If no item is selected, hides completion menu. Else, inserts a newline character. </li> </ul> Unfortunately, Neovim's builtin completion mechanism does not offer any support for snippets by default. That's why we have mini.snippets</code>. But to be fair, newer versions of Neovim do have some support for snippets... but even with that, it still doesn't offer as many features as mini.snippets</code>. The LSP client</h2> Neovim's LSP client is the thing that enables the nice IDE-like features. Things like go to definition, rename variable, inspect function signature. You get the idea. But this "client" doesn't work on its own, it needs a server. In this case a "server" is an external program that implements the LSP specification</a>. If you want to know more details about LSP and language servers, watch this video by TJ DeVries: LSP explained (5 min)</a>. What do we need to do here? We follow these 3 steps. Install a language server</li> Configure that language server</li> Create some keymaps (optional)</li> </ul> Step 1: Install a language server</h3> The Neovim community has created a resource where we can find a list of language servers. This list is in nvim-lspconfig</code> documentation: configs.md</a>. Since I need some examples for the next step I'm going to show the install commands for the go</code> language server and the rust</code> language server. If you have the toolchain for the go programming language</a> you can download its language server (gopls</code>) using this command. go install golang.org/x/tools/gopls@latest</code></pre> If you have rustup</a> installed you can download rust_analyzer</code> using this command. rustup component add rust-analyzer</code></pre>Step 2: Configure a language server</h3> Now you have to "enable" each language server you have installed in your system. On Neovim v0.11 you can use the function vim.lsp.enable()</a>. vim.lsp.enable('example_server')</code></pre> On Neovim v0.10 or lower you must use the "legacy setup" function of nvim-lspconfig</code>. require('lspconfig').example_server.setup({})</code></pre> If you have the language server for go</code> and rust</code> you would do this. vim.lsp.enable({'gopls', 'rust_analyzer'})</code></pre> Or this. require('lspconfig').gopls.setup({}) require('lspconfig').rust_analyzer.setup({})</code></pre> If you want your config to be backwards compatible you can write a function that uses the correct method. -- This function will use the "legacy setup" on older Neovim version. -- The new api is only available on Neovim v0.11 or greater. local function lsp_setup(server, opts) if vim.fn.has('nvim-0.11') == 0 then require('lspconfig')[server].setup(opts) return end if not vim.tbl_isempty(opts) then vim.lsp.config(server, opts) end vim.lsp.enable(server) end</code></pre> Then you can write the setup like this: lsp_setup('gopls', {}) lsp_setup('rust_analyzer', {})</code></pre> Do note there are a handful of language servers that can't be configured with vim.lsp.enable()</code>. The list of missing servers is in this github issue: nvim-lspconfig/issues/3705</a>. Step 3: Create keymaps</h3> After a language server is active in the current buffer we can use the functions under the module vim.lsp.buf</a>. On Neovim v0.11 we have a handful of keymaps that trigger functions on this module. But on older versions we have to create the keymaps ourselves. -- NOTE: These keymaps are already part of Neovim v0.11. -- You do not have to add them to your personal configuration -- if you are using Neovim v0.11 or greater. -- Displays a function's signature information vim.keymap.set('i', '<C-s>', '<cmd>lua vim.lsp.buf.signature_help()<cr>') -- Lists all symbols in the current buffer vim.keymap.set('n', 'gO', '<cmd>lua vim.lsp.buf.document_symbol()<cr>') -- Lists all the implementations for the symbol under the cursor vim.keymap.set('n', 'gri', '<cmd>lua vim.lsp.buf.implementation()<cr>') -- Jumps to the definition of the type symbol vim.keymap.set('n', 'grt', '<cmd>lua vim.lsp.buf.type_definition()<cr>') -- Lists all the references vim.keymap.set('n', 'grr', '<cmd>lua vim.lsp.buf.references()<cr>') -- Renames all references to the symbol under the cursor vim.keymap.set('n', 'grn', '<cmd>lua vim.lsp.buf.rename()<cr>') -- Selects a code action available at the current cursor position vim.keymap.set('n', 'gra', '<cmd>lua vim.lsp.buf.code_action()<cr>') -- Show diagnostics in a floating window vim.keymap.set('n', '<C-w>d', '<cmd>lua vim.diagnostic.open_float()<cr>') vim.keymap.set('n', '<C-w><C-d>', '<cmd>lua vim.diagnostic.open_float()<cr>') -- Jump next/previous diagnostic in the current buffer vim.keymap.set('n', '[d', '<cmd>lua vim.diagnostic.goto_prev()<cr>') vim.keymap.set('n', ']d', '<cmd>lua vim.diagnostic.goto_next()<cr>') vim.api.nvim_create_autocmd('LspAttach', { callback = function(event) -- NOTE: By default `K` uses the program specified in 'keywordprg' -- Here we force it to use the LSP client -- Display documentation of the symbol under the cursor vim.keymap.set('n', 'K', '<cmd>lua vim.lsp.buf.hover()<cr>', {buffer = event.buf}) end, })</code></pre>Keep in mind</h3> Every language server is an independent project. A language server can have its own unique configuration method outside of Neovim. They can have bugs, limitations and quirks. Some language servers were created for VS Code, the fact that Neovim and other editors can use them is just a happy accident. I believe the language servers for html</code> and css</code> fit in this category. They can have features that only work on VS Code. For example, Neovim can't enable the language server for css</code> inside an html</code> style tag (see issue 26783</a>). That probably works fine in VS Code. Honorable mention</h2> nvim-treesitter</a> is a plugin that has been around since 2020. A lot of people will say it's essential to your Neovim experience, and I do agree to some extend. It is incredibly useful... as a dependency for other plugins. It allows Neovim to gather more information about source code of the current file, and plugin authors can do really cool things with that. Treesitter became known in the community because it could be used to enhance the syntax highlight of many programming languages. There are things you need to be aware of: It needs a C</code> compiler. Not a problem on linux or mac but it is a problem on windows.</li> </ul> </li> It only supports the latest stable version of Neovim. It can drop the support for previous versions of Neovim really fast.</li> </ul> </li> Is considered experimental. It can introduce breaking changes at any point in time.</li> They do use git tags</code> to track versions</a>, in case you need a specific version.</li> </ul> </li> </ul> To know more about tree-sitter</code> watch this video: tree-sitter explained (15 min)</a>. If you decide to try it, you can use the command :TSInstall</code> to download a treesitter parser for the language you want, and then you can enable the enhanced syntax highlight using an autocommand. For example, you can download the treesitter parser for javascript using this command. :TSInstall javascript</code></pre> And then create an autocommand that will call the function vim.treesitter.start()</code> in any filetype that uses javascript syntax. Like this. vim.api.nvim_create_autocmd('FileType', { pattern = {'javascript', 'javascriptreact', 'js', 'jsx'}, callback = function() vim.treesitter.start() end, })</code></pre>init.lua</h2> And this is it. This is all you need to get started if you are using Neovim v0.12. If you need backwards compatibility with Neovim v0.9, use this other configuration instead</a>. -- NOTE: This configuration is meant for Neovim v0.12 or greater -- Learn about Neovim's lua api -- https://neovim.io/doc/user/lua-guide.html vim.o.number = true vim.o.tabstop = 2 vim.o.shiftwidth = 2 vim.o.smartcase = true vim.o.ignorecase = true vim.o.wrap = false vim.o.hlsearch = false vim.o.signcolumn = 'yes' -- Space as the leader key vim.g.mapleader = vim.keycode('<Space>') -- Basic clipboard interaction vim.keymap.set({'n', 'x'}, 'gy', '"+y', {desc = 'Copy to clipboard'}) vim.keymap.set({'n', 'x'}, 'gp', '"+p', {desc = 'Paste clipboard text'}) -- Command shortcuts vim.keymap.set('n', '<leader>w', '<cmd>write<cr>', {desc = 'Save file'}) vim.keymap.set('n', '<leader>q', '<cmd>quitall<cr>', {desc = 'Exit vim'}) vim.cmd.colorscheme('retrobox') vim.pack.add({ 'https://github.com/neovim/nvim-lspconfig', 'https://github.com/nvim-mini/mini.nvim', }) require('mini.snippets').setup({}) require('mini.completion').setup({}) require('mini.files').setup({}) vim.keymap.set('n', '<leader>e', '<cmd>lua MiniFiles.open()<cr>', {desc = 'File explorer'}) require('mini.pick').setup({}) vim.keymap.set('n', '<leader><space>', '<cmd>Pick buffers<cr>', {desc = 'Search open files'}) vim.keymap.set('n', '<leader>ff', '<cmd>Pick files<cr>', {desc = 'Search all files'}) vim.keymap.set('n', '<leader>fh', '<cmd>Pick help<cr>', {desc = 'Search help tags'}) -- List of compatible language servers is here: -- https://github.com/neovim/nvim-lspconfig/blob/master/doc/configs.md vim.lsp.enable({'gopls', 'rust_analyzer'})</code></pre>Backwards compatible config</h2> For those of you that are using Ubuntu or Debian based operating systems, you have to be aware of the version available in the official repo of your system. In Ubuntu 24.04 you'll have v0.9.5</code>. And any system based on Debian 13 will have v0.10.4</code> available. You can still have a good experience using older versions of Neovim but the configuration will be a little bit more complex. -- NOTE: This is meant to be backwards compatible with Neovim v0.9.5 -- Learn about Neovim's lua api -- https://neovim.io/doc/user/lua-guide.html vim.o.number = true vim.o.tabstop = 2 vim.o.shiftwidth = 2 vim.o.smartcase = true vim.o.ignorecase = true vim.o.wrap = false vim.o.hlsearch = false vim.o.signcolumn = 'yes' -- Space as the leader key vim.g.mapleader = ' ' -- Basic clipboard interaction vim.keymap.set({'n', 'x'}, 'gy', '"+y', {desc = 'Copy to clipboard'}) vim.keymap.set({'n', 'x'}, 'gp', '"+p', {desc = 'Paste clipboard text'}) -- Command shortcuts vim.keymap.set('n', '<leader>w', '<cmd>write<cr>', {desc = 'Save file'}) vim.keymap.set('n', '<leader>q', '<cmd>quitall<cr>', {desc = 'Exit vim'}) local ok_theme = pcall(vim.cmd.colorscheme, 'retrobox') if not ok_theme then vim.cmd.colorscheme('habamax') end local ok, MiniDeps = pcall(require, 'mini.deps') if not ok then vim.notify('[WARN] mini.deps module not found', vim.log.levels.WARN) return end MiniDeps.setup({}) MiniDeps.add({ source = 'nvim-mini/mini.nvim', checkout = '3923662bf3d6ca49a9503f8d7196ea0450983e6a', }) MiniDeps.add({ source = 'neovim/nvim-lspconfig', checkout = vim.fn.has('nvim-0.10') == 1 and 'v2.5.0' or 'v1.8.0' }) require('mini.snippets').setup({}) require('mini.completion').setup({}) require('mini.files').setup({}) vim.keymap.set('n', '<leader>e', '<cmd>lua MiniFiles.open()<cr>', {desc = 'File explorer'}) require('mini.pick').setup({}) vim.keymap.set('n', '<leader><space>', '<cmd>Pick buffers<cr>', {desc = 'Search open files'}) vim.keymap.set('n', '<leader>ff', '<cmd>Pick files<cr>', {desc = 'Search all files'}) vim.keymap.set('n', '<leader>fh', '<cmd>Pick help<cr>', {desc = 'Search help tags'}) -- Displays a function's signature information vim.keymap.set('i', '<C-s>', '<cmd>lua vim.lsp.buf.signature_help()<cr>') -- Lists all symbols in the current buffer vim.keymap.set('n', 'gO', '<cmd>lua vim.lsp.buf.document_symbol()<cr>') -- Lists all the implementations for the symbol under the cursor vim.keymap.set('n', 'gri', '<cmd>lua vim.lsp.buf.implementation()<cr>') -- Jumps to the definition of the type symbol vim.keymap.set('n', 'grt', '<cmd>lua vim.lsp.buf.type_definition()<cr>') -- Lists all the references vim.keymap.set('n', 'grr', '<cmd>lua vim.lsp.buf.references()<cr>') -- Renames all references to the symbol under the cursor vim.keymap.set('n', 'grn', '<cmd>lua vim.lsp.buf.rename()<cr>') -- Selects a code action available at the current cursor position vim.keymap.set('n', 'gra', '<cmd>lua vim.lsp.buf.code_action()<cr>') -- Show diagnostics in a floating window vim.keymap.set('n', '<C-w>d', '<cmd>lua vim.diagnostic.open_float()<cr>') vim.keymap.set('n', '<C-w><C-d>', '<cmd>lua vim.diagnostic.open_float()<cr>') if vim.fn.has('nvim-0.11') == 0 then -- Jump next/previous diagnostic in the current buffer vim.keymap.set('n', '[d', '<cmd>lua vim.diagnostic.goto_prev()<cr>') vim.keymap.set('n', ']d', '<cmd>lua vim.diagnostic.goto_next()<cr>') end vim.api.nvim_create_autocmd('LspAttach', { callback = function(event) -- NOTE: By default `K` uses the program specified in the 'keywordprg' option. -- Here we override the default behavior, we force it to use the LSP client -- Display documentation of the symbol under the cursor vim.keymap.set('n', 'K', '<cmd>lua vim.lsp.buf.hover()<cr>', {buffer = event.buf}) end, }) -- This function will use the "legacy setup" on older Neovim version. -- The new api is only available on Neovim v0.11 or greater. local function lsp_setup(server, opts) if vim.fn.has('nvim-0.11') == 0 then require('lspconfig')[server].setup(opts) return end if not vim.tbl_isempty(opts) then vim.lsp.config(server, opts) end vim.lsp.enable(server) end -- List of compatible language servers is here: -- https://github.com/neovim/nvim-lspconfig/blob/master/doc/configs.md lsp_setup('gopls', {}) lsp_setup('rust_analyzer', {})</code></pre>

Devlog

Simple Neovim config

Navigating between files</h2> For educational purposes only, I will tell you what I do when I don't have plugins installed: I use the files</code> command to list the open files, then use the buffer</code> command to navigate the file I want. And to make it convenient I make a keymap.</p>

Step 2: Configure a language server</h3> Now you have to "enable" each language server you have installed in your system.</p>

Keep in mind</h3> Every language server is an independent project. A language server can have its own unique configuration method outside of Neovim. They can have bugs, limitations and quirks.</p>

Neovim: Install plugins without a plugin manager

A guide on Neovim's LSP client

Requirements</h2> Neovim v0.8 or greater.</li> A language server.</li>

Basic Usage</h2> Before we write any code we should learn how to use the language server. This should be in the official documentation of said server.</p>

Where to look if something goes wrong?</h2> If Neovim wasn't able to start the language server, you can take a look at the log file, execute this command inside Neovim:</p>

vim.diagnostic</h3> There is a lua module dedicated specifically to diagnostics: vim.diagnostic</a>. This has a .config()</a> function we can use to configure the interface of the diagnostics.</p> Hide diagnostic signs</li> </ul> This is the safe way to disable the diagnostics sign.</p>

Disable semantic highlights</h3> To opt-out of this feature Neovim's documentation suggest that we "delete" a property from the LSP client instance.</p>

Expand snippets</h3> Neovim v0.11 or greater is required.</p> </blockquote>

Enable inlay hints</h3> Neovim v0.10 or greater is required.</p> </blockquote>

How to survive without multiple cursors in vim