FuzzyBot: Updating to match new version of source page

2025-11-20T14:22:35Z

Updating to match new version of source page

← Older revision		Revision as of 14:22, 20 November 2025
Line 151:		Line 151:
	Vim plugins can be installed with the help of nix. You can omit using vim plugin managers and do everything in your <code>.nixpkgs/config</code>.		Vim plugins can be installed with the help of nix. You can omit using vim plugin managers and do everything in your <code>.nixpkgs/config</code>.

	A lot of documentation about package management and configuration of vim in nix is stored at [https://github.com/NixOS/nixpkgs/blob/master/~~pkgs~~/~~applications/editors~~/vim~~/plugins/vim-utils~~.~~nix~~] in nixpkgs.		A lot of documentation about package management and configuration of vim in nix is stored at [https://github.com/NixOS/nixpkgs/blob/master/doc/languages-frameworks/vim.section.md] in nixpkgs.

	=== Customizations ===		=== Customizations ===

FuzzyBot: Updating to match new version of source page

2025-10-07T20:14:49Z

Updating to match new version of source page

Show changes

FuzzyBot: Updating to match new version of source page

2024-07-30T12:02:57Z

Updating to match new version of source page

FuzzyBot: Updating to match new version of source page

2024-07-30T09:46:03Z

Updating to match new version of source page

Show changes

FuzzyBot: Updating to match new version of source page

2024-07-21T02:41:16Z

Updating to match new version of source page

New page

<languages/>
[https://www.vim.org/ Vim] (vi improved) is a highly configurable modal text editor program for the terminal.

== Installation ==

=== Basic Install ===

<syntaxhighlight lang="nix>
environment.systemPackages = with pkgs; [ vim ];
</syntaxhighlight>

or

<syntaxhighlight lang="nix>
environment.systemPackages = with pkgs; [ vim_configurable ];
</syntaxhighlight>

=== Using Home Manager ===

Vim can easily be set up using [[Special:MyLanguage/Home Manager|Home Manager]]. Here's a minimal example:
<syntaxhighlight lang="nix>
programs.vim = {
enable = true;
plugins = with pkgs.vimPlugins; [ vim-airline ];
settings = { ignorecase = true; };
extraConfig = ''
set mouse=a
'';
};
</syntaxhighlight>

See [https://github.com/rycee/home-manager/blob/master/modules/programs/vim.nix] for the full set of options.

=== Vim Spell Files ===

You can configure home-manager to install spelling files into your user directory by packaging individual spell files. Here' an example for neovim and French:

<syntaxHighlight lang="nix">
let
nvim-spell-fr-utf8-dictionary = builtins.fetchurl {
url = "http://ftp.vim.org/vim/runtime/spell/fr.utf-8.spl";
sha256 = "abfb9702b98d887c175ace58f1ab39733dc08d03b674d914f56344ef86e63b61";
};

nvim-spell-fr-utf8-suggestions = builtins.fetchurl {
url = "http://ftp.vim.org/vim/runtime/spell/fr.utf-8.sug";
sha256 = "0294bc32b42c90bbb286a89e23ca3773b7ef50eff1ab523b1513d6a25c6b3f58";
};

nvim-spell-fr-latin1-dictionary = builtins.fetchurl {
url = "http://ftp.vim.org/vim/runtime/spell/fr.latin1.spl";
sha256 = "086ccda0891594c93eab143aa83ffbbd25d013c1b82866bbb48bb1cb788cc2ff";
};

nvim-spell-fr-latin1-suggestions = builtins.fetchurl {
url = "http://ftp.vim.org/vim/runtime/spell/fr.latin1.sug";
sha256 = "5cb2c97901b9ca81bf765532099c0329e2223c139baa764058822debd2e0d22a";
};
in
{
home.file."${config.xdg.configHome}/nvim/spell/fr.utf-8.spl".source = nvim-spell-fr-utf8-dictionary;
home.file."${config.xdg.configHome}/nvim/spell/fr.utf-8.sug".source = nvim-spell-fr-utf8-suggestions;
home.file."${config.xdg.configHome}/nvim/spell/fr.latin1.spl".source = nvim-spell-fr-latin1-dictionary;
home.file."${config.xdg.configHome}/nvim/spell/fr.latin1.sug".source = nvim-spell-fr-latin1-suggestions;
}
</syntaxHighlight>

==== NeoVim with Coc for Python ====

For NeoVim use this home manager config:
https://github.com/NixOS/nixpkgs/issues/98166#issuecomment-725319238

== System wide vim/nvim configuration ==

If you want a system wide "baseline" configuration for vim/nvim here are two examples:.

<syntaxHighlight lang="nix">
{ pkgs, ... }:
{
environment.variables = { EDITOR = "vim"; };

environment.systemPackages = with pkgs; [
((vim_configurable.override { }).customize{
name = "vim";
# Install plugins for example for syntax highlighting of nix files
vimrcConfig.packages.myplugins = with pkgs.vimPlugins; {
start = [ vim-nix vim-lastplace ];
opt = [];
};
vimrcConfig.customRC = ''
" your custom vimrc
set nocompatible
set backspace=indent,eol,start
" Turn on syntax highlighting by default
syntax on
" ...
'';
}
)];
}
</syntaxHighlight>

<syntaxHighlight lang="nix">
{ pkgs, ... }:
{
environment.variables = { EDITOR = "vim"; };

environment.systemPackages = with pkgs; [
(neovim.override {
vimAlias = true;
extraConfig = ''
" your custom vimrc
set nocompatible
set backspace=indent,eol,start
" ...
'';
configure = {
packages.myPlugins = with pkgs.vimPlugins; {
start = [ vim-lastplace vim-nix ];
opt = [];
};
};
}
)];
}
</syntaxHighlight>

import these in your <code>configuration.nix</code> and
<syntaxHighlight lang="nix">
{
imports =
[
./vim.nix
];
# ...
}
</syntaxHighlight>

== Custom setup without using Home Manager ==

{{note|To get a general overview about how to set up your vim in nix, refer to [https://www.mpscholten.de/nixos/2016/04/11/setting-up-vim-on-nixos.html mpscholten's blog] }}

Vim plugins can be installed with the help of nix. You can omit using vim plugin managers and do everything in your <code>.nixpkgs/config</code>.

A lot of documentation about package management and configuration of vim in nix is stored at [https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/editors/vim/plugins/vim-utils.nix] in nixpkgs.

=== Customizations ===

Both vim and neovim can be further configured to include your favorite plugins and additional libraries. To list all available vim plugins, run <code>nix search nixpkgs#vimPlugins</code>.

Add the following code to your <code>~/.nixpkgs/config.nix</code>:

<syntaxHighlight lang="nix">
{
packageOverrides = pkgs: with pkgs; {
myVim = vim_configurable.customize {
name = "vim-with-plugins";
# add here code from the example section
};
myNeovim = neovim.override {
configure = {
customRC = ''
# here your custom configuration goes!
'';
packages.myVimPackage = with pkgs.vimPlugins; {
# see examples below how to use custom packages
start = [ ];
opt = [ ];
};
};
};
};
}
</syntaxHighlight>

After that you can install your special grafted `myVim` or `myNeovim` packages.

=== Examples ===

==== Apply custom vimrc configuration ====

NB: you ''must'' use <code>vimrcConfig.customRC</code> rather than installing a <code>~/.vimrc</code> by hand, since the customized Vim will silently ignore any vimrc in your home directory.

<syntaxHighlight lang="nix">
vim_configurable.customize {
name = "vim-with-plugins";
# add custom .vimrc lines like this:
vimrcConfig.customRC = ''
set hidden
set colorcolumn=80
'';
}
</syntaxHighlight>

If you need to run code before plugins are added, you can use <code>vimrcConfig.beforePlugins</code> (be sure to include <code>set nocompatible</code> if you override [https://github.com/NixOS/nixpkgs/blob/c3df8057dad986bf7f3928de1b5233fadb52bb15/pkgs/misc/vim-plugins/vim-utils.nix#L264-L267 the default value]).

=== Using vim's builtin packaging capability ===

<syntaxHighlight lang="nix">
vim_configurable.customize {
vimrcConfig.packages.myVimPackage = with pkgs.vimPlugins; {
# loaded on launch
start = [ YouCompleteMe fugitive ];
# manually loadable by calling `:packadd $plugin-name`
opt = [ phpCompletion elm-vim ];
# To automatically load a plugin when opening a filetype, add vimrc lines like:
# autocmd FileType php :packadd phpCompletion
}
};
</syntaxHighlight>

Note that dynamically loading with opt may be buggy and the workaround is to use [https://vi.stackexchange.com/a/20818/30821 start instead].

=== Using Pathogen as manager ===

There is a pathogen implementation as well, but its startup is slower and [VAM] has more features.
<syntaxhighlight lang="nix">
vimrcConfig.pathogen.knownPlugins = vimPlugins; # optional
vimrcConfig.pathogen.pluginNames = [ "vim-addon-nix" "youcompleteme" ];
</syntaxhighlight>

=== Using Vim-Plug as manager ===

<syntaxhighlight lang="nix">
vimrcConfig.plug.plugins = with pkgs.vimPlugins; [vim-addon-nix youcompleteme];
</syntaxhighlight>

=== Adding new plugins ===

As per the instructions found in https://github.com/NixOS/nixpkgs/blob/master/doc/languages-frameworks/vim.section.md
* First run <code>./update.py</code>.
* Commit the changes with the commit message "vimPlugins: Update".
* Add your plugin to ./vim-plugin-names (please try to maintain the list alphabetically sorted). You can customize the branch by appending for example <code>@main</code> to an entry (search the file for examples)
* Run <code>./update.py</code> once again to generate the plugin's nix expression.
* Commit your changes one more time, this time with the message formated as such: "vimPlugins.[plugin-name]: init at [version]".
* If you need to add additional code/patches to the generated code, add those lines to <code>pkgs/misc/vim-plugins/vim2nix/additional-nix-code</code> and rerun <code>./update.py</code>. They will be included in the generated code.

==== Notes Regarding Plugins ====

For additional info, you may wish to look at [https://github.com/NixOS/nixpkgs/blob/master/doc/languages-frameworks/vim.section.md documentation on the nixpkgs repository].

=== Add a new custom plugin to the users packages ===

Sometimes you do not want to change upstream plugins, for this you can use <code>vimUtils.buildVimPlugin</code> to create your own:

<syntaxHighlight lang="nix">
let
vim-better-whitespace = pkgs.vimUtils.buildVimPlugin {
name = "vim-better-whitespace";
src = pkgs.fetchFromGitHub {
owner = "ntpeters";
repo = "vim-better-whitespace";
rev = "984c8da518799a6bfb8214e1acdcfd10f5f1eed7";
sha256 = "10l01a8xaivz6n01x6hzfx7gd0igd0wcf9ril0sllqzbq7yx2bbk";
};
};

in {
users.users.<yourNickname>.packages = [
(pkgs.vim_configurable.customize {
vimrcConfig.packages.myVimPackage = with pkgs.vimPlugins; {
start = [ vim-better-whitespace ];
};
})
];
};
</syntaxHighlight>

==== Using flake ====

<code>configuration.nix</code>:
<syntaxHighlight lang="nix">
{ inputs, ... }:
{
nixpkgs = {
overlays = [
(self: super:
let
winresizer-vim = super.vimUtils.buildVimPlugin {
name = "winresizer-vim";
src = inputs.winresizer-vim;
};
in
{
vimPlugins =
super.vimPlugins // {
inherit winresizer-vim;
};
}
)
];
};
</syntaxHighlight>

<code>flake.nix</code>:
<syntaxHighlight lang="nix">
{
inputs = {
nixpkgs.url = "github:nixos/nixpkgs/nixos-22.05";
winresizer-vim = {
url = "github:simeji/winresizer";
flake = false;
};
};

outputs = inputs@{ nixpkgs, ... }: {
nixosConfigurations.nixos = nixpkgs.lib.nixosSystem {
system = "x86_64-linux";
specialArgs = { inherit inputs; };
modules = [
./configuration.nix
./hardware-configuration.nix
{ nix.registry.nixpkgs.flake = nixpkgs; }
];
};
};
}
</syntaxHighlight>

Then we can update the package with <code>nix flake lock --update-input winresizer-vim</code>, or update all inputs in flake.nix with <code>nix flake update</code>.

=== Vim as a Python IDE ===

The following snippet will make a full featured python IDE.

==== Using language client ====

<syntaxHighlight lang="nix">
vim_configurable.customize {
vimrcConfig = {
customRC = ''
let g:LanguageClient_serverCommands = {
\ 'python': ['pyls']
\ }
nnoremap <F5> :call LanguageClient_contextMenu()<CR>
nnoremap <silent> gh :call LanguageClient_textDocument_hover()<CR>
nnoremap <silent> gd :call LanguageClient_textDocument_definition()<CR>
nnoremap <silent> gr :call LanguageClient_textDocument_references()<CR>
nnoremap <silent> gs :call LanguageClient_textDocument_documentSymbol()<CR>
nnoremap <silent> <F2> :call LanguageClient_textDocument_rename()<CR>
nnoremap <silent> gf :call LanguageClient_textDocument_formatting()<CR>
'';
packages.myVimPackage = with pkgs.vimPlugins; {
start = [ LanguageClient-neovim ];
}
};
</syntaxHighlight>

Then put the following expression in <code>environment.systemPackages</code> or in the home-manager package list,
to install python-language-server:

<syntaxHighlight lang="nix">
(python3.withPackages(ps: [
ps.python-language-server
# the following plugins are optional, they provide type checking, import sorting and code formatting
ps.pyls-mypy ps.pyls-isort ps.pyls-black
]))
</syntaxHighlight>

=== Real life examples ===

* [https://github.com/jagajaga/my_configs/blob/master/.nixpkgs/common.nix Jagajaga’s config]
* [https://github.com/andrewrk/dotfiles/blob/master/.nixpkgs/config.nix andrewrk's config]
* [https://github.com/wagnerf42/nixos-config/blob/master/config/my_vim.nix wagnerf42's config (good for rust language)]

=== YouCompleteMe ===

Currently the youcompleteme plugin uses [https://github.com/NixOS/nixpkgs/blob/8e7b1f2ac2e261d5a644fef860a0d050ea227c06/pkgs/misc/vim-plugins/default.nix#L695 unwrapped clang on linux]. This causes it to not find <code>stdlib.h</code>. There is a [https://github.com/andrewrk/genesis/blob/5f49cd9a8c2b61b9859a22102bc3f732add9461a/.ycm_extra_conf.py workaround] you can put in your <code>.ycm_extra_conf.py</code> file, which works by executing the C/C++ compiler and getting it to output the list of search paths - which includes the search path to find <code>stdlib.h</code>.

A better alternative to youcompleteme for C/C++ is to use [https://github.com/cquery-project/cquery/ cquery] in combination with the [https://github.com/autozimu/LanguageClient-neovim LanguageClient-neovim]. It will also find in c header files when used in a nix-shell if you install cquery from nixpkgs as it uses a custom [https://github.com/NixOS/nixpkgs/commit/04f3b76dcec21f2fcba6b1b0afbb3ed224165050#diff-11cdfc0385b9e017089c1ac09c5b838e shell wrapper]

== Python 3 support for vim ==

If you have defined your vim configuration in a `./my_vim.nix` file you can install vim with the python 3 support instead of python2 by overriding the python version like the following:

<syntaxHighlight lang="nix">
(pkgs.callPackage ./my_vim.nix {
vim_configurable = vim_configurable.override { python = python3; };
})
</syntaxHighlight>

== gvim and gview ==

<code>gvim</code> and <code>gview</code> may be installed using the <code>[https://search.nixos.org/packages/?query=vimHugeX vimHugeX]</code> attribute name (package name <code>[https://search.nixos.org/packages/?query=vim_configurable vim_configurable]</code>).
<syntaxhighlight lang=bash>
$ nix-env -iA nixos.vimHugeX
</syntaxhighlight>

If you are using <code>vim_configurable.customize</code>, you can enable <code>wrapGui</code> to make <code>gvim</code> available, though this won't give you <code>gview</code>:
<syntaxhighlight lang=nix>
vim_configured = pkgs.vim_configurable.customize {
name = "vim";
wrapGui = true;
};
</syntaxhighlight>

[[Category:Applications]]
[[Category:Text Editor{{#translation:}}]]

← Older revision		Revision as of 12:02, 30 July 2024
Line 275:		Line 275:

	As per the instructions found in https://github.com/NixOS/nixpkgs/blob/master/doc/languages-frameworks/vim.section.md		As per the instructions found in https://github.com/NixOS/nixpkgs/blob/master/doc/languages-frameworks/vim.section.md

	* First run <code>./update.py</code>.		* First run <code>./update.py</code>.

	* Commit the changes with the commit message "vimPlugins: Update".		* Commit the changes with the commit message "vimPlugins: Update".

	* Add your plugin to ./vim-plugin-names (please try to maintain the list alphabetically sorted). You can customize the branch by appending for example <code>@main</code> to an entry (search the file for examples)		* Add your plugin to ./vim-plugin-names (please try to maintain the list alphabetically sorted). You can customize the branch by appending for example <code>@main</code> to an entry (search the file for examples)

	* Run <code>./update.py</code> once again to generate the plugin's nix expression.		* Run <code>./update.py</code> once again to generate the plugin's nix expression.

	* Commit your changes one more time, this time with the message formated as such: "vimPlugins.[plugin-name]: init at [version]".		* Commit your changes one more time, this time with the message formated as such: "vimPlugins.[plugin-name]: init at [version]".

	* If you need to add additional code/patches to the generated code, add those lines to <code>pkgs/misc/vim-plugins/vim2nix/additional-nix-code</code> and rerun <code>./update.py</code>. They will be included in the generated code.		* If you need to add additional code/patches to the generated code, add those lines to <code>pkgs/misc/vim-plugins/vim2nix/additional-nix-code</code> and rerun <code>./update.py</code>. They will be included in the generated code.

Line 406:		Line 412:

	* [https://github.com/jagajaga/my_configs/blob/master/.nixpkgs/common.nix Jagajaga’s config]		* [https://github.com/jagajaga/my_configs/blob/master/.nixpkgs/common.nix Jagajaga’s config]

	* [https://github.com/andrewrk/dotfiles/blob/master/.nixpkgs/config.nix andrewrk's config]		* [https://github.com/andrewrk/dotfiles/blob/master/.nixpkgs/config.nix andrewrk's config]

	* [https://github.com/wagnerf42/nixos-config/blob/master/config/my_vim.nix wagnerf42's config (good for rust language)]		* [https://github.com/wagnerf42/nixos-config/blob/master/config/my_vim.nix wagnerf42's config (good for rust language)]

Line 440:		Line 448:
	wrapGui = true;		wrapGui = true;
	};		};
	</syntaxhighlight		</syntaxhighlight>

	[[Category:Applications]]		[[Category:Applications]]
	[[Category:Text Editor{{#translation:}}]]		[[Category:Text Editor{{#translation:}}]]

Vim/en - Revision history

FuzzyBot: Updating to match new version of source page

FuzzyBot: Updating to match new version of source page

FuzzyBot: Updating to match new version of source page

FuzzyBot: Updating to match new version of source page

FuzzyBot: Updating to match new version of source page