nvf

https://nvf.notashelf.dev/
Admin
nvf is a highly modular and configurable Neovim configuration framework built on Nix that allows...
Tokens:49,122
Snippets:674
Trust Score:7.9
Update:3 months ago
Show doc for...
Tokens:
Raw
### Example Flake Installation

Source: https://nvf.notashelf.dev/index.html

Full example of integrating nvf into a home-manager configuration within a flake.

```nix
{  
  inputs = {  
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";  
    home-manager.url = "github:nix-community/home-manager";  
    nvf.url = "github:notashelf/nvf";  
  };  
  
  outputs = { nixpkgs, home-manager, nvf, ... }: {  
    # ↓ this is your home output in the flake schema, expected by home-manager  
    "your-username@your-hostname" = home-manager.lib.homeManagerConfiguration {  
      pkgs = nixpkgs.legacyPackages.x86_64-linux;  
      modules = [  
        nvf.homeManagerModules.default # <- this imports the home-manager module that provides the options  
        ./home.nix # <- your home entrypoint, `programs.nvf.*` may be defined here  
      ];  
    };  
  };  
}  
```

--------------------------------

### Example flake installation

Source: https://nvf.notashelf.dev/index.html

A complete example of integrating nvf into a NixOS system configuration within a flake.

```nix
{
  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
    nvf.url = "github:notashelf/nvf";
  };

  outputs = { nixpkgs, nvf, ... }: {
    # ↓ this is your host output in the flake schema
    nixosConfigurations."your-hostname" = nixpkgs.lib.nixosSystem {
      modules = [
        nvf.nixosModules.default # <- this imports the NixOS module that provides the options
        ./configuration.nix # <- your host entrypoint, `programs.nvf.*` may be defined here
      ];
    };
  };
}
```

--------------------------------

### Configure a plugin with manual setup

Source: https://nvf.notashelf.dev/tips.html

Use vim.extraPlugins to define a package and its associated setup function.

```nix
{  
  vim.extraPlugins = {  
    aerial = {  
      package = pkgs.vimPlugins.aerial-nvim;  
      setup = "require('aerial').setup {}";  
    };  
  };  
}  
```

--------------------------------

### Define lazy-loaded plugins

Source: https://nvf.notashelf.dev/options.html

Example of defining plugins with specific setup modules, options, post-load hooks, and command triggers.

```nix
''
  {
    toggleterm-nvim = {
      package = "toggleterm-nvim";
      setupModule = "toggleterm";
      setupOpts = cfg.setupOpts;
  
      after = "require('toggleterm').do_something()";
      cmd = ["ToggleTerm"];
    };
  
    $''${pkgs.vimPlugins.vim-bbye.pname} = {
      package = pkgs.vimPlugins.vim-bbye;
      cmd = ["Bdelete" "Bwipeout"];
    };
  }
''
```

--------------------------------

### Configure Textobjects Setup Options

Source: https://nvf.notashelf.dev/options.html

Provide a configuration table for the treesitter-textobjects setup function.

```nix
{
  select = {
    enable = true;
    keymaps = {
      af = "@function.outer";
    };
    lookahead = true;
  };
}
```

--------------------------------

### Configure Telescope extensions

Source: https://nvf.notashelf.dev/options.html

Example configuration for adding a Telescope extension.

```nix
[
  {
    name = "fzf";
    packages = [pkgs.vimPlugins.telescope-fzf-native-nvim];
    setup = {fzf = {fuzzy = true;};};
  }
]
```

--------------------------------

### Configure color and style options

Source: https://nvf.notashelf.dev/options.html

Examples of values for highlight attributes.

```nix
"#ebdbb2"
```

```nix
false
```

--------------------------------

### Configure vim.optPlugins

Source: https://nvf.notashelf.dev/options.html

Example of adding a plugin to the optional plugins list.

```nix
[pkgs.vimPlugins.vim-ghost]
```

--------------------------------

### Implement plugin configuration logic

Source: https://nvf.notashelf.dev/hacking.html

Use the defined setup options to generate the Lua configuration for the plugin.

```nix
# in modules/.../your-plugin/config.nix
{lib, config, ...}:
let
  cfg = config.vim.your-plugin;
in {
  vim.luaConfigRC = lib.nvim.dag.entryAnywhere ''
    require('plugin-name').setup(${lib.nvim.lua.toLuaObject cfg.setupOpts})
  '';
}
```

--------------------------------

### Define startup plugins

Source: https://nvf.notashelf.dev/options.html

Example of adding a plugin to the startup list using the Nix package manager syntax.

```nix
[pkgs.vimPlugins.telescope-nvim]
```

--------------------------------

### Inject Post-Configuration Lua

Source: https://nvf.notashelf.dev/options.html

Example of reading a Lua file to be inserted after the main configuration.

```nix
${builtins.readFile ./my-lua-config-post.lua}
```

--------------------------------

### Inject Pre-Configuration Lua

Source: https://nvf.notashelf.dev/options.html

Example of reading a Lua file to be inserted before the main configuration.

```nix
${builtins.readFile ./my-lua-config-pre.lua}
```

--------------------------------

### Configure themable option

Source: https://nvf.notashelf.dev/options.html

Example value for the themable configuration option.

```nix
false
```

--------------------------------

### Configure vim.options

Source: https://nvf.notashelf.dev/options.html

Example of setting a Vim option using an attribute set.

```nix
{
  visualbell = true;
}
```

--------------------------------

### Configure extra plugin setup

Source: https://nvf.notashelf.dev/options.html

Defines Lua code to execute during the setup phase of an extra plugin.

```lua
require('aerial').setup {}
```

--------------------------------

### Configure Filetype Formatters

Source: https://nvf.notashelf.dev/options.html

Example mapping of filetypes to specific formatters.

```nix
{
  lua = [
    "stylua"
  ];
}
```

--------------------------------

### Configure nvimTree window picker

Source: https://nvf.notashelf.dev/options.html

Example of using the s1n7ax/nvim-window-picker plugin as the window picker for nvimTree.

```lua
-- with s1n7ax/nvim-window-picker plugin
require('window-picker').pick_window,
```

--------------------------------

### Configure LSP Servers

Source: https://nvf.notashelf.dev/options.html

Example configuration for managing LSP servers using the Neovim 0.11 API.

```nix
''
  {
    "*" = {
      root_markers = [".git"];
      capabilities = {
        textDocument = {
          semanticTokens = {
            multilineTokenSupport = true;
          };
        };
      };
    };
  
    "clangd" = {
      filetypes = ["c"];
    };
  }
''
```

--------------------------------

### Standalone Flake Configuration Example

Source: https://nvf.notashelf.dev/index.html

An example of a flake file that exposes a custom Neovim configuration using nvf as a standalone module.

```nix
{  
  inputs = {  
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";  
    nvf.url = "github:notashelf/nvf";  
  };  
  
  outputs = {nixpkgs, ...} @ inputs: {  
    packages.x86_64-linux = {  
      # Set the default package to the wrapped instance of Neovim.  
      # This will allow running your Neovim configuration with  
      # `nix run` and in addition, sharing your configuration with  
      # other users in case your repository is public.  
      default =  
        (inputs.nvf.lib.neovimConfiguration {  
          pkgs = nixpkgs.legacyPackages.x86_64-linux;  
          modules = [  
            {  
              config.vim = {  
                # Enable custom theming options  
                theme.enable = true;  
  
                # Enable Treesitter  
                treesitter.enable = true;  
  
                # Other options will go here. Refer to the config  
                # reference in Appendix B of the nvf manual.  
                # ...  
              };  
            }  
          ];  
        })  
        .neovim;  
    };  
  };  
}  
```

--------------------------------

### Define modular plugin setup options

Source: https://nvf.notashelf.dev/hacking.html

Use mkPluginSetupOption to define configurable options for a plugin in a modular way.

```nix
# in modules/.../your-plugin/your-plugin.nix

{lib, ...}:
let
  inherit (lib.types) bool int;
  inherit (lib.nvim.types) mkPluginSetupOption;
in {
  options.vim.your-plugin = {
    setupOpts = mkPluginSetupOption "plugin name" {
      enable_feature_a = mkOption {
        type = bool;
        default = false;
        # ...
      };

      number_option = mkOption {
        type = int;
        default = 3;
        # ...
      };
    };
  };
}
```

--------------------------------

### Configure nvim-notify setup options

Source: https://nvf.notashelf.dev/options.html

Defines the base configuration table for nvim-notify.

```nix
{ }
```

--------------------------------

### Define Provider Settings

Source: https://nvf.notashelf.dev/options.html

Example configuration for various LLM providers including OpenAI, Ollama, and Groq.

```nix
  openai = {
    endpoint = "https://api.openai.com/v1";
    model = "gpt-4o"; # your desired model (or use gpt-4o, etc.)
    timeout = 30000; # Timeout in milliseconds, increase this for reasoning models
    extra_request_body = {
      temperature = 0;
      max_completion_tokens = 8192; # Increase this to include reasoning tokens (for reasoning models)
      reasoning_effort = "medium"; # low|medium|high, only used for reasoning models
    };
  };
  ollama = {
    endpoint = "http://127.0.0.1:11434";
    timeout = 30000; # Timeout in milliseconds
    extra_request_body = {
      options = {
        temperature = 0.75;
        num_ctx = 20480;
        keep_alive = "5m";
      };
    };
  };
  groq = {
    __inherited_from = "openai";
    api_key_name = "GROQ_API_KEY";
    endpoint = "https://api.groq.com/openai/v1/";
    model = "llama-3.3-70b-versatile";
    disable_tools = true;
    extra_request_body = {
      temperature = 1;
      max_tokens = 32768; # remember to increase this value, otherwise it will stop generating halfway
    };
  };
```

--------------------------------

### vim.ui.colorizer.setupOpts.user_default_options

Source: https://nvf.notashelf.dev/options.html

Defines default colorization behavior applied globally, acting as the inverse of specific setup configurations.

```APIDOC
## vim.ui.colorizer.setupOpts.user_default_options

### Description
Global default settings for the colorizer plugin. These settings are applied unless overridden by filetype-specific configurations.

### Parameters
- **AARRGGBB** (boolean) - Optional - Colorize 0xAARRGGBB hex codes.
- **RGB** (boolean) - Optional - Colorize #RGB hex codes.
- **RRGGBB** (boolean) - Optional - Colorize #RRGGBB hex codes.
- **RRGGBBAA** (boolean) - Optional - Colorize #RRGGBBAA hex codes.
```

--------------------------------

### User configuration for plugin options

Source: https://nvf.notashelf.dev/hacking.html

Example of how a user can override or extend plugin options in their configuration.

```nix
# in user's config
{
  vim.your-plugin.setupOpts = {
    enable_feature_a = true;
    number_option = 4;
    another_field = "hello";
    size = { # nested fields work as well
      top = 10;
    };
  };
}
```

--------------------------------

### Configure Precognition Highlight Colors

Source: https://nvf.notashelf.dev/options.html

Examples for defining highlight colors for virtual text.

```nix
{
 link = "Comment"; }
# or
{ foreground = "#0000FF"; background = "#000000"; };
```

--------------------------------

### Configure Lua Options

Source: https://nvf.notashelf.dev/options.html

Example of setting standard Neovim options via the Lua configuration block.

```lua
-- Set the tab size to 4 spaces
vim.opt.tabstop = 4
vim.opt.shiftwidth = 4
vim.opt.expandtab = true
```

--------------------------------

### Manual Java Debugging Setup

Source: https://nvf.notashelf.dev/options.html

Commands for building and running a Java application with debug symbols and a socket for JLS.

```bash
javac -g ...
```

```bash
java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005 -jar your.jar
```

--------------------------------

### Configure Harpoon setup options

Source: https://nvf.notashelf.dev/options.html

Defines the default key lookup behavior for Harpoon using a Lua expression.

```nix
{   _type = "lua-inline";   expr = ''     function()       return vim.uv.cwd()     end   ''; }
```

--------------------------------

### Defining additional runtime paths

Source: https://nvf.notashelf.dev/options.html

Example of providing a list of paths to be appended to the Neovim runtimepath.

```nix
[

```

--------------------------------

### Configure nvf options

Source: https://nvf.notashelf.dev/index.html

Use the programs.nvf module option to customize your nvf installation.

```nix
{
  programs.nvf = {
    enable = true;
    # Your settings need to go into the settings attribute set
    # most settings are documented in the appendix
    settings = {
      vim.viAlias = false;
      vim.vimAlias = true;
      vim.lsp = {
        enable = true;
      };
    };
  };
}
```

--------------------------------

### Configure plugins with extraPlugins

Source: https://nvf.notashelf.dev/configuring.html

Use the extraPlugins API to define packages and setup strings with built-in abstraction for load order.

```nix
{pkgs, ...}: {  
  config.vim.extraPlugins = {  
    aerial = {  
      package = pkgs.vimPlugins.aerial-nvim;  
      setup = ''  
        require('aerial').setup {  
          -- some lua configuration here  
        }  
      '';  
    };  
  
    harpoon = {  
      package = pkgs.vimPlugins.harpoon;  
      setup = "require('harpoon').setup {}";  
      after = ["aerial"];  
    };  
  };  
}  
```

--------------------------------

### Set Precognition Hint Priority

Source: https://nvf.notashelf.dev/options.html

Example of setting a priority value for a gutter hint.

```nix
10
```

--------------------------------

### Configure Gradle Executable

Source: https://nvf.notashelf.dev/options.html

Examples for setting the gradle executable path using either the system PATH or a specific Nix package.

```nix
''
  - `"gradle"`: to use the gradle from the `PATH`.
  - `"$${getExe pkgs.gradle}"`: to use gradle from a nix package.
''
```

--------------------------------

### Configure Extra Plugins

Source: https://nvf.notashelf.dev/options.html

Attribute set defining custom plugins and their setup configurations, supporting dependency ordering.

```nix
with pkgs.vimPlugins; {
  aerial = {
    package = aerial-nvim;
    setup = "require('aerial').setup {}";
  };

  harpoon = {
    package = harpoon;
    setup = "require('harpoon').setup {}";
    after = ["aerial"]; # place harpoon configuration after aerial
  };
}
```

--------------------------------

### Define Path Options

Source: https://nvf.notashelf.dev/options.html

Examples of defining paths as absolute strings, relative paths, or using the Nix builtins.path function.

```nix
"$HOME/.config/nvim-extra"
```

```nix
./nvim
```

```nix
(builtins.path {
  path = ./runtime; # this must be a relative path
  name = "nvim-runtime"; # name is arbitrary
})
```

--------------------------------

### Configure lazy-load key mappings

Source: https://nvf.notashelf.dev/options.html

Example of defining key mappings that trigger plugin loading, supporting both string actions and Lua functions.

```nix
''
  keys = [
    {
      mode = "n";
      key = "<leader>s";
      action = ":DapStepOver<cr>";
      desc = "DAP Step Over";
    }
    {
      mode = ["n", "x"];
      key = "<leader>dc";
      action = "function() require('dap').continue() end";
      lua = true;
      desc = "DAP Continue";
    }
  ]
''
```

--------------------------------

### Configure ccc.nvim picker conversion

Source: https://nvf.notashelf.dev/options.html

Example of specifying picker and output pairs using mkLuaInline for the ccc plugin.

```nix
map (map mkLuaInline) [  
  ["ccc.picker.hex", "ccc.output.css_rgb"]  
  ["ccc.picker.css_rgb", "ccc.output.hex"]  
];  
```

--------------------------------

### Run nvf configurations with Nix

Source: https://nvf.notashelf.dev/index.html

Commands to execute prebuilt nvf configurations directly from the flake without permanent installation.

```bash
# Add the nvf cache  
$ cachix use nvf                   # Optional: it'll save you CPU resources and time  
  
# Run the minimal configuration with the cache enabled  
$ nix run github:notashelf/nvf#nix # Will run the default minimal configuration  
```

```bash
$ nix run github:notashelf/nvf#nix  
$ nix run github:notashelf/nvf#maximal  
```

```bash
$ nix run github:notashelf/nvf#nix test.nix  
# => This will open a file called `test.nix` with Nix LSP and syntax highlighting  
```

```bash
$ nix run github:notashelf/nvf#maximal -- test.nix  
# => This will open a file called `test.nix` with a variety of plugins available  
```

--------------------------------

### Configure filetype-specific colorizer settings

Source: https://nvf.notashelf.dev/options.html

Example configuration for enabling or disabling colorizer features across different filetypes using the filetypes attribute set.

```nix
{
  "!vim" = { };
  "*" = { };
  javascript = {
    AARRGGBB = false;
  };
}
```

--------------------------------

### Define plugins using the standard API

Source: https://nvf.notashelf.dev/configuring.html

The extraPlugins attribute set allows defining packages and setup code, with support for DAG-based ordering via the after field.

```nix
{pkgs, ...}: {  
  config.vim.extraPlugins = {  
    aerial = {  
      package = pkgs.vimPlugins.aerial-nvim;  
      setup = "require('aerial').setup {}";  
    };  
  
    harpoon = {  
      package = pkgs.vimPlugins.harpoon;  
      setup = "require('harpoon').setup {}";  
      after = ["aerial"]; # place harpoon configuration after aerial  
    };  
  };  
}  
```

--------------------------------

### Configure lazy-loaded plugins with setupOpts

Source: https://nvf.notashelf.dev/configuring.html

Use setupModule and setupOpts for plugins following the require('module').setup() pattern, or use before/after hooks for custom execution.

```nix
{  
  config.vim.lazy.plugins = {  
    "aerial.nvim" = {  
    # ^^^^^^^^^ this name should match the package.pname or package.name  
      package = aerial-nvim;  
  
      setupModule = "aerial";  
      setupOpts = {option_name = false;};  
  
      after = "print('aerial loaded')";  
    };  
  };  
}  
```

--------------------------------

### Example Commit Messages

Source: https://nvf.notashelf.dev/hacking.html

Examples of properly formatted commit messages for various types of changes.

```text
starship: allow running in Emacs if vterm is used

The vterm buffer is backed by libvterm and can handle Starship prompts
without issues.
```

```text
languages/ruby: init module

Adds a language module for Ruby, adds appropriate formatters and Treesitter
grammars
```

```text
plugin: init
```

```text
neotree: init

This adds the neo-tree plugin.
```

--------------------------------

### vim.lsp.lspkind.setupOpts

Source: https://nvf.notashelf.dev/options.html

Configuration options for lspkind, including modification hooks and display modes.

```APIDOC
## vim.lsp.lspkind.setupOpts

### Description
Configuration for lspkind plugin behavior.

### Options
- **before** (null or luaInline) - Function called before lspkind modifications.
- **mode** (string: "text", "text_symbol", "symbol_text", "symbol") - Defines how annotations are shown. Default: "symbol_text"
```

--------------------------------

### Add a simple plugin from Nixpkgs

Source: https://nvf.notashelf.dev/tips.html

Use vim.startPlugins to add a plugin that does not require manual configuration.

```nix
{pkgs, ...}: {  
  # Aerial does require some setup. In the case you pass a plugin that *does*
  # require manual setup, then you must also call the setup function.
  vim.startPlugins = [pkgs.vimPlugins.aerial-nvim];  
}  
```

--------------------------------

### Define a postInstall phase for complex plugins

Source: https://nvf.notashelf.dev/hacking.html

Use this in a derivation to copy built libraries and plugin files to the output directory.

```nix
{
  # ...
  
  postInstall = ''
    cp -r {lua,plugin} "$out"

    mkdir -p "$out/doc"
    cp 'doc/'*'.txt' "$out/doc/"

    mkdir -p "$out/target"
    mv "$out/lib" "$out/target/release"
  '';
  
  # ...
}
```

--------------------------------

### Configure Diff Timeout

Source: https://nvf.notashelf.dev/options.html

Example value for overriding the diff timeout setting.

```nix
-1
```

--------------------------------

### Generated Lua configuration

Source: https://nvf.notashelf.dev/hacking.html

The resulting Lua code produced by the modular setup configuration.

```lua
require('plugin-name').setup({
  enable_feature_a = false,
  number_option = 3,
})
```

--------------------------------

### Add plugins via startPlugins

Source: https://nvf.notashelf.dev/configuring.html

Register a plugin package in the runtime by adding it to the startPlugins list.

```nix
{pkgs, ...}: {  
  # Add a Neovim plugin from Nixpkgs to the runtime.  
  # This does not need to come explicitly from packages. 'vim.startPlugins'  
  # takes a list of *string* (to load internal plugins) or *package* to load  
  # a Neovim package from any source.  
  vim.startPlugins = [pkgs.vimPlugins.aerial-nvim];  
}  
```

--------------------------------

### Configure csvview parser comments

Source: https://nvf.notashelf.dev/options.html

Example of defining comment prefixes for the CSV parser.

```nix
["#" "//"]
```

--------------------------------

### Configure Typst Preview Open Command

Source: https://nvf.notashelf.dev/options.html

Sets a custom format string for opening the preview output link.

```nix
"firefox %s -P typst-preview --class typst-preview"
```

--------------------------------

### Build and Open NVF Manual

Source: https://nvf.notashelf.dev/hacking.html

Commands to generate the HTML manual and open it in a browser.

```bash
# Build the online manual  
$ nix build .#docs-html  
  
# Open it with a valid browser  
$ xdg-open $PWD/result/share/doc/index.html  
```

--------------------------------

### vim.ui.noice.setupOpts

Source: https://nvf.notashelf.dev/options.html

Configuration options for the Noice UI plugin, including message routing and LSP documentation borders.

```APIDOC
## vim.ui.noice.setupOpts

### Description
Configuration settings for the Noice plugin.

### Options
- **presets.lsp_doc_border** (boolean) - Optional - Add a border to hover docs and signature help. Default: false.
- **routes** (list) - Optional - How to route messages. Default: "Hide written messages".
- **routes.*.filter** (anything) - Optional - A filter for messages matching this route.
- **routes.*.opts** (anything) - Optional - Options for the view and the route. Default: null.
- **routes.*.view** (string) - Optional - How this route is viewed. Default: null.
```

--------------------------------

### Define custom highlight groups

Source: https://nvf.notashelf.dev/options.html

Example of defining a custom highlight group for the SignColumn.

```nix
{
  SignColumn = {
    bg = "#282828";
  };
}
```

--------------------------------

### Initialize npins environment

Source: https://nvf.notashelf.dev/hacking.html

Use this command to prepare the environment for adding plugins via npins.

```bash
nix-shell -p npins # or nix shell nixpkgs#npins if using flakes
```

--------------------------------

### Configure Treesitter Grammars

Source: https://nvf.notashelf.dev/options.html

Specify a list of grammars to install using the nvim-treesitter plugin parsers.

```nix
with pkgs.vimPlugins.nvim-treesitter.grammarPlugins; [
  regex
  kdl
];
```

--------------------------------

### Implement plugin key mappings with helpers

Source: https://nvf.notashelf.dev/hacking.html

Use mkMappingOption to define mapping options in a plugin definition and mkKeymap to register them in the configuration.

```nix
# pluginDefinition.nix  
{lib, ...}: let  
  inherit (lib.options) mkEnableOption;  
  inherit (config.vim.lib) mkMappingOption;  
in {  
  options.vim.plugin = {  
    enable = mkEnableOption "Enable plugin";  
  
    # Mappings should always be inside an attrset called mappings  
    mappings = {  
      workspaceDiagnostics = mkMappingOption "Workspace diagnostics [trouble]" "<leader>lwd";  
      documentDiagnostics = mkMappingOption "Document diagnostics [trouble]" "<leader>ld";  
      lspReferences = mkMappingOption "LSP References [trouble]" "<leader>lr";  
      quickfix = mkMappingOption "QuickFix [trouble]" "<leader>xq";  
      locList = mkMappingOption "LOCList [trouble]" "<leader>xl";  
      symbols = mkMappingOption "Symbols [trouble]" "<leader>xs";  
    };
}
```

```nix
# config.nix  
{  
  config,  
  lib,  
  options,  
  ...  
}: let  
  inherit (lib.modules) mkIf;  
  inherit (lib.nvim.binds) mkKeymap;  
  
  cfg = config.vim.plugin;  
  
  keys = cfg.mappings;  
  inherit (options.vim.lsp.trouble) mappings;  
in {  
  config = mkIf cfg.enable {  
    vim.keymaps = [  
      (mkKeymap "n" keys.workspaceDiagnostics "<cmd>Trouble toggle diagnostics<CR>" {desc = mappings.workspaceDiagnostics.description;})  
      (mkKeymap "n" keys.documentDiagnostics "<cmd>Trouble toggle diagnostics filter.buf=0<CR>" {desc = mappings.documentDiagnostics.description;})  
      (mkKeymap "n" keys.lspReferences "<cmd>Trouble toggle lsp_references<CR>" {desc = mappings.lspReferences.description;})  
      (mkKeymap "n" keys.quickfix "<cmd>Trouble toggle quickfix<CR>" {desc = mappings.quickfix.description;})  
      (mkKeymap "n" keys.locList "<cmd>Trouble toggle loclist<CR>" {desc = mappings.locList.description;})  
      (mkKeymap "n" keys.symbols "<cmd>Trouble toggle symbols<CR>" {desc = mappings.symbols.description;})  
    ];  
  };
}
```

--------------------------------

### Build a plugin using fetchFromGitHub

Source: https://nvf.notashelf.dev/tips.html

Manually define a plugin source using fetchFromGitHub and optionally skip specific modules during build checks.

```nix
regexplainer = buildVimPlugin {
  name = "nvim-regexplainer";
  src = fetchFromGitHub {
    owner = "bennypowers";
    repo = "nvim-regexplainer";
    rev = "4250c8f3c1307876384e70eeedde5149249e154f";
    hash = "sha256-15DLbKtOgUPq4DcF71jFYu31faDn52k3P1x47GL3+b0=";
  };

  # The 'buildVimPlugin' imposes some "require checks" on all plugins build from
  # source. Failing tests, if they are not relevant, can be disabled using the
  # 'nvimSkipModule' argument to the 'buildVimPlugin' function.
  nvimSkipModule = [
    "regexplainer"
    "regexplainer.buffers.init"
    "regexplainer.buffers.popup"
    "regexplainer.buffers.register"
    "regexplainer.buffers.shared"
    "regexplainer.buffers.split"
    "regexplainer.component.descriptions"
    "regexplainer.component.init"
    "regexplainer.renderers.narrative.init"
    "regexplainer.renderers.narrative.narrative"
    "regexplainer.renderers.init"
    "regexplainer.utils.defer"
    "regexplainer.utils.init"
    "regexplainer.utils.treesitter"
  ];
}  
```

--------------------------------

### Configure Rustaceanvim LSP Server

Source: https://nvf.notashelf.dev/options.html

LSP configuration for rustaceanvim, including custom keymaps via on_attach.

```nix
{   cmd = [     "${pkgs.rust-analyzer.out}/bin/rust-analyzer"   ];   on_attach = {     _type = "lua-inline";     expr = ''       function(client, bufnr)           default_on_attach(client, bufnr)           local opts = { noremap=true, silent=true, buffer = bufnr }                  vim.keymap.set("n", "<localleader>rr", ":RustLsp runnables<CR>", opts)       vim.keymap.set("n", "<localleader>rp", ":RustLsp parentModule<CR>", opts)       vim.keymap.set("n", "<localleader>rm", ":RustLsp expandMacro<CR>", opts)       vim.keymap.set("n", "<localleader>rc", ":RustLsp openCargo", opts)       vim.keymap.set("n", "<localleader>rg", ":RustLsp crateGraph x11", opts)                                                  end     '';   }; }
```

```nix
{
  on_attach = {
    _type = "lua-inline";
    expr = ''
      function(client, bufnr)
            -- you can also put keymaps in here
      end,
    '';
  };
}
```

--------------------------------

### vim.visuals.tiny-devicons-auto-colors.setupOpts

Source: https://nvf.notashelf.dev/options.html

Configuration options for the tiny-devicons-auto-colors plugin.

```APIDOC
## vim.visuals.tiny-devicons-auto-colors.setupOpts

### Description
Option table to pass into the setup function of tiny-devicons-auto-colors.

### Type
luaInline or open submodule

### Default
{ }
```

--------------------------------

### Configure Darwin Module Option

Source: https://nvf.notashelf.dev/release-notes.html

Example of the error encountered when importing a NixOS module into a Darwin flake.

```text
(class: "nixos") cannot be imported into a module
evaluation that expects class "darwin".
```

--------------------------------

### Define Lua configuration in ~/.config/nvf

Source: https://nvf.notashelf.dev/tips.html

Example Lua configuration file content for the impure directory method.

```lua
-- init.lua  
vim.keymap.set("n", " ", "<Nop>", { silent = true, remap = false })  
vim.g.mapleader = " "  
```

--------------------------------

### Configure vim.globals

Source: https://nvf.notashelf.dev/options.html

Sets global variables for Neovim. The provided example sets a variable named some_variable to 42.

```nix
{
  some_variable = 42;
}
```

--------------------------------

### vim.tabline.nvimBufferline.setupOpts.options

Source: https://nvf.notashelf.dev/options.html

Configuration options for the bufferline component, controlling appearance, sorting, and behavior of buffers.

```APIDOC
## Configuration: vim.tabline.nvimBufferline.setupOpts.options

### Description
Settings to customize the bufferline display, including icons, sorting methods, and visual styles.

### Options
- **persist_buffer_sort** (boolean) - Whether custom sorted buffers should persist. Default: true
- **right_mouse_command** (string/null) - Command to run when right clicking a buffer. Default: "vertical sbuffer %d"
- **right_trunc_marker** (string) - Icon for right truncation. Default: ""
- **separator_style** (string/list) - Style of separators. Options: "slant", "padded_slant", "slope", "padded_slope", "thick", "thin". Default: "thin"
- **show_buffer_close_icons** (boolean) - Show buffer close icons. Default: true
- **show_buffer_icons** (boolean) - Show buffer icons. Default: true
- **show_close_icon** (boolean) - Show the close icon. Default: true
- **show_duplicate_prefix** (boolean) - Show duplicate buffer prefixes. Default: true
- **show_tab_indicators** (boolean) - Show tab indicators. Default: true
- **sort_by** (string) - Method to sort buffers. Options: "insert_after_current", "insert_at_end", "id", "extension", "relative_directory", "directory", "tabs". Default: "extension"
- **style_preset** (string) - Base style of bufferline. Options: "default", "minimal", "no_bold", "no_italic". Default: "default"
- **tab_size** (integer) - Size of the tabs. Default: 18
- **themable** (boolean) - Allow highlight groups to be overridden. Default: true
- **truncate_names** (boolean) - Truncate names. Default: true
```

--------------------------------

### Define mkLuaInline usage in Nix

Source: https://nvf.notashelf.dev/configuring.html

Example of using mkLuaInline to define a Lua function within a Nix expression.

```nix
let  
  inherit (lib.generators) mkLuaInline;  
in {  
  foo = mkLuaInline ''  
    function bar()  
      return 'foobar'  
    end  
  '';  
}  
```

--------------------------------

### Configure startify bookmarks

Source: https://nvf.notashelf.dev/options.html

Define a set of bookmarks for the startify dashboard.

```nix
{
  c = "~/.vimrc";
}
```

--------------------------------

### Embedding Lua functions in Nix configuration

Source: https://nvf.notashelf.dev/hacking.html

Using mkLuaInline to pass a Lua function into a plugin's setup options.

```nix
let 
  inherit (lib.generators) mkLuaInline;
in {
   vim.your-plugin.setupOpts = {
     on_init = mkLuaInline ''
       function()
         print('we can write lua!')
       end
     '';
   };
}
```

--------------------------------

### Reference a plugin in configuration

Source: https://nvf.notashelf.dev/hacking.html

Add the plugin name to the startPlugins list after adding it via npins.

```nix
{
  config.vim.startPlugins = ["lazydev-nvim"];
}
```

```nix
{
  config.vim.startPlugins = ["blink-cmp"];
}
```

--------------------------------

### vim.ui.colorizer.setupOpts.filetypes

Source: https://nvf.notashelf.dev/options.html

Defines the filetypes to enable colorization on, along with specific option overrides for each filetype.

```APIDOC
## vim.ui.colorizer.setupOpts.filetypes

### Description
Configures which filetypes should have colorization enabled. Use "*" to enable on all filetypes, or prefix with "!" to disable specific filetypes.

### Parameters
- **<name>** (submodule) - Required - The filetype name or wildcard pattern.

### Example
```json
{
  "!vim": {},
  "*": {},
  "javascript": {
    "AARRGGBB": false
  }
}
```
```

--------------------------------

### Configure Typst Preview Extra Arguments

Source: https://nvf.notashelf.dev/options.html

Provides a list of extra arguments to pass to the typst-previewer.

```nix
[
  "--input=ver=draft"
  "--ignore-system-fonts"
]
```

--------------------------------

### Configure Fidget.nvim Progress Display Overrides

Source: https://nvf.notashelf.dev/options.html

Defines default notification group settings and provides an example of overriding specific LSP server configurations.

```lua
   {  
       name = "Notifications",  
       icon = "❰❰",  
       ttl = 5,  
       group_style = "Title",  
       icon_style = "Special",  
       annote_style = "Question",  
       debug_style = "Comment",  
       info_style = "Question",  
       warn_style = "WarningMsg",  
       error_style = "ErrorMsg",  
       debug_annote = "DEBUG",  
       info_annote = "INFO",  
       warn_annote = "WARN",  
       error_annote = "ERROR",  
       update_hook = function(item)  
         notification.set_content_key(item)  
       end,  
   }  
```

```lua
{
  rust_analyzer = {
    name = "Rust Analyzer";
  };
}
```

--------------------------------

### Enable Avante Plugin

Source: https://nvf.notashelf.dev/options.html

Boolean flag to enable the avante.nvim plugin.

```nix
true
```

--------------------------------

### Configure Lazy-Loaded Plugins in nvf

Source: https://nvf.notashelf.dev/configuring.html

Defines a lazy-loaded plugin configuration including setup modules, options, and various trigger conditions like commands, events, and keymaps.

```nix
{  
  config.vim.lazy.plugins = {  
    "aerial.nvim" = {  
      package = pkgs.vimPlugins.aerial-nvim;  
      setupModule = "aerial";  
      setupOpts = {  
        option_name = true;  
      };  
      after = ''  
        -- custom lua code to run after plugin is loaded  
        print('aerial loaded')  
      '';  
  
      # Explicitly mark plugin as lazy. You don't need this if you define one of  
      # the trigger "events" below  
      lazy = true;  
  
      # load on command  
      cmd = ["AerialOpen"];  
  
      # load on event  
      event = ["BufEnter"];  
  
      # load on keymap  
      keys = [  
        {  
          key = "<leader>a";  
          action = ":AerialToggle<CR>";  
        }  
      ];  
    };  
  };  
}  
```

--------------------------------

### View NVF configuration with syntax highlighting

Source: https://nvf.notashelf.dev/tips.html

Use the bat pager to display the built NVF configuration with syntax highlighting.

```bash
nvf-print-config | bat --language=lua
```

--------------------------------

### Run Documentation Link Checker

Source: https://nvf.notashelf.dev/hacking.html

Command to build the package responsible for identifying dead URLs in the documentation.

```bash
# Build the link checker package  
$ nix build .#docs-linkcheck  
```

--------------------------------

### Build a plugin from a flake input

Source: https://nvf.notashelf.dev/tips.html

Use buildVimPlugin to create a plugin package from a local flake input source.

```nix
# Make sure that 'inputs' is properly propagated! It will be missing otherwise
# and the resulting errors might be too obscure.
{inputs, ...}: let  
  aerial-from-source = pkgs.vimUtils.buildVimPlugin {
      name = "aerial-nvim";
      src = inputs.aerial-nvim;
    };
in {  
  vim.extraPlugins = {  
    aerial = {  
      package = aerial-from-source;
      setup = "require('aerial').setup {}";  
    };  
  };  
}  
```

--------------------------------

### vim.lsp.lspsaga

Source: https://nvf.notashelf.dev/options.html

Configuration for enabling and setting up LSP Saga.

```APIDOC
## vim.lsp.lspsaga

### Description
Settings for the LSP Saga plugin.

### Options
- **enable** (boolean) - Whether to enable LSP Saga. Default: false.
- **setupOpts** (luaInline or submodule) - Options table passed to the setup function.
- **setupOpts.border_style** (string or list) - Border type for windows. Default: "rounded"
```
Tokens:
Raw