Merge 7d077f43f7 into f1849c0ce5

configuration.nix

@@ -1,233 +1,260 @@
-isMaximal: {
-  config.vim = {
-    viAlias = true;
-    vimAlias = true;
-    debugMode = {
-      enable = false;
-      level = 16;
-      logFile = "/tmp/nvim.log";
+inputs: let
+  modulesWithInputs = import ./modules inputs;
+
+  neovimConfiguration = {
+    modules ? [],
+    pkgs,
+    lib ? pkgs.lib,
+    check ? true,
+    extraSpecialArgs ? {},
+    extraModules ? [],
+    ...
+  }:
+    modulesWithInputs {
+      inherit pkgs lib check extraSpecialArgs extraModules;
+      configuration.imports = modules;
     };
 
-    spellcheck = {
-      enable = isMaximal;
-    };
-
-    lsp = {
-      formatOnSave = true;
-      lspkind.enable = false;
-      lightbulb.enable = true;
-      lspsaga.enable = false;
-      nvimCodeActionMenu.enable = isMaximal;
-      trouble.enable = true;
-      lspSignature.enable = true;
-      lsplines.enable = isMaximal;
-      nvim-docs-view.enable = isMaximal;
-    };
-
-    debugger = {
-      nvim-dap = {
-        enable = true;
-        ui.enable = true;
+  mainConfig = isMaximal: {
+    config.vim = {
+      viAlias = true;
+      vimAlias = true;
+      debugMode = {
+        enable = false;
+        level = 16;
+        logFile = "/tmp/nvim.log";
       };
-    };
 
-    languages = {
-      enableLSP = true;
-      enableFormat = true;
-      enableTreesitter = true;
-      enableExtraDiagnostics = true;
-
-      # Nim LSP is broken on Darwin and therefore
-      # should be disabled by default. Users may still enable
-      # `vim.languages.vim` to enable it, this does not restrict
-      # that.
-      # See: <https://github.com/PMunch/nimlsp/issues/178#issue-2128106096>
-      nim.enable = false;
-
-      nix.enable = true;
-
-      markdown.enable = isMaximal;
-      html.enable = isMaximal;
-      css.enable = isMaximal;
-      sql.enable = isMaximal;
-      java.enable = isMaximal;
-      ts.enable = isMaximal;
-      svelte.enable = isMaximal;
-      go.enable = isMaximal;
-      elixir.enable = isMaximal;
-      zig.enable = isMaximal;
-      ocaml.enable = isMaximal;
-      python.enable = isMaximal;
-      dart.enable = isMaximal;
-      bash.enable = isMaximal;
-      tailwind.enable = isMaximal;
-      typst.enable = isMaximal;
-      clang = {
+      spellcheck = {
         enable = isMaximal;
-        lsp.server = "clangd";
       };
 
-      rust = {
-        enable = isMaximal;
-        crates.enable = isMaximal;
-      };
-    };
-
-    visuals = {
-      enable = true;
-      nvimWebDevicons.enable = true;
-      scrollBar.enable = isMaximal;
-      smoothScroll.enable = true;
-      cellularAutomaton.enable = false;
-      fidget-nvim.enable = true;
-      highlight-undo.enable = true;
-
-      indentBlankline.enable = true;
-
-      cursorline = {
-        enable = true;
-        lineTimeout = 0;
-      };
-    };
-
-    statusline = {
-      lualine = {
-        enable = true;
-        theme = "catppuccin";
-      };
-    };
-
-    theme = {
-      enable = true;
-      name = "catppuccin";
-      style = "mocha";
-      transparent = false;
-    };
-
-    autopairs.enable = true;
-
-    autocomplete = {
-      enable = true;
-      type = "nvim-cmp";
-    };
-
-    filetree = {
-      nvimTree = {
-        enable = true;
-      };
-    };
-
-    tabline = {
-      nvimBufferline.enable = true;
-    };
-
-    treesitter.context.enable = true;
-
-    binds = {
-      whichKey.enable = true;
-      cheatsheet.enable = true;
-    };
-
-    telescope.enable = true;
-
-    git = {
-      enable = true;
-      gitsigns.enable = true;
-      gitsigns.codeActions.enable = false; # throws an annoying debug message
-    };
-
-    minimap = {
-      minimap-vim.enable = false;
-      codewindow.enable = isMaximal; # lighter, faster, and uses lua for configuration
-    };
-
-    dashboard = {
-      dashboard-nvim.enable = false;
-      alpha.enable = isMaximal;
-    };
-
-    notify = {
-      nvim-notify.enable = true;
-    };
-
-    projects = {
-      project-nvim.enable = isMaximal;
-    };
-
-    utility = {
-      ccc.enable = isMaximal;
-      vim-wakatime.enable = false;
-      icon-picker.enable = isMaximal;
-      surround.enable = isMaximal;
-      diffview-nvim.enable = true;
-      motion = {
-        hop.enable = true;
-        leap.enable = true;
+      lsp = {
+        formatOnSave = true;
+        lspkind.enable = false;
+        lightbulb.enable = true;
+        lspsaga.enable = false;
+        nvimCodeActionMenu.enable = isMaximal;
+        trouble.enable = true;
+        lspSignature.enable = true;
+        lsplines.enable = isMaximal;
+        nvim-docs-view.enable = isMaximal;
       };
 
-      images = {
-        image-nvim.enable = false;
-      };
-    };
-
-    notes = {
-      obsidian.enable = false; # FIXME: neovim fails to build if obsidian is enabled
-      orgmode.enable = false;
-      mind-nvim.enable = isMaximal;
-      todo-comments.enable = true;
-    };
-
-    terminal = {
-      toggleterm = {
-        enable = true;
-        lazygit.enable = true;
-      };
-    };
-
-    ui = {
-      borders.enable = true;
-      noice.enable = true;
-      colorizer.enable = true;
-      modes-nvim.enable = false; # the theme looks terrible with catppuccin
-      illuminate.enable = true;
-      breadcrumbs = {
-        enable = isMaximal;
-        navbuddy.enable = isMaximal;
-      };
-      smartcolumn = {
-        enable = true;
-        setupOpts.custom_colorcolumn = {
-          # this is a freeform module, it's `buftype = int;` for configuring column position
-          nix = "110";
-          ruby = "120";
-          java = "130";
-          go = ["90" "130"];
+      debugger = {
+        nvim-dap = {
+          enable = true;
+          ui.enable = true;
         };
       };
-    };
 
-    assistant = {
-      chatgpt.enable = false;
-      copilot = {
-        enable = false;
-        cmp.enable = isMaximal;
+      languages = {
+        enableLSP = true;
+        enableFormat = true;
+        enableTreesitter = true;
+        enableExtraDiagnostics = true;
+
+        # Nim LSP is broken on Darwin and therefore
+        # should be disabled by default. Users may still enable
+        # `vim.languages.vim` to enable it, this does not restrict
+        # that.
+        # See: <https://github.com/PMunch/nimlsp/issues/178#issue-2128106096>
+        nim.enable = false;
+
+        nix.enable = true;
+
+        markdown.enable = isMaximal;
+        html.enable = isMaximal;
+        css.enable = isMaximal;
+        sql.enable = isMaximal;
+        java.enable = isMaximal;
+        ts.enable = isMaximal;
+        svelte.enable = isMaximal;
+        go.enable = isMaximal;
+        elixir.enable = isMaximal;
+        zig.enable = isMaximal;
+        ocaml.enable = isMaximal;
+        python.enable = isMaximal;
+        dart.enable = isMaximal;
+        bash.enable = isMaximal;
+        tailwind.enable = isMaximal;
+        typst.enable = isMaximal;
+        clang = {
+          enable = isMaximal;
+          lsp.server = "clangd";
+        };
+
+        rust = {
+          enable = isMaximal;
+          crates.enable = isMaximal;
+        };
+      };
+
+      visuals = {
+        enable = true;
+        nvimWebDevicons.enable = true;
+        scrollBar.enable = isMaximal;
+        smoothScroll.enable = true;
+        cellularAutomaton.enable = false;
+        fidget-nvim.enable = true;
+        highlight-undo.enable = true;
+
+        indentBlankline = {
+          enable = true;
+          fillChar = null;
+          eolChar = null;
+          scope = {
+            enabled = true;
+          };
+        };
+
+        cursorline = {
+          enable = true;
+          lineTimeout = 0;
+        };
+      };
+
+      statusline = {
+        lualine = {
+          enable = true;
+          theme = "catppuccin";
+        };
+      };
+
+      theme = {
+        enable = true;
+        name = "catppuccin";
+        style = "mocha";
+        transparent = false;
+      };
+
+      autopairs.enable = true;
+
+      autocomplete = {
+        enable = true;
+        type = "nvim-cmp";
+      };
+
+      filetree = {
+        nvimTree = {
+          enable = true;
+        };
+      };
+
+      tabline = {
+        nvimBufferline.enable = true;
+      };
+
+      treesitter.context.enable = true;
+
+      binds = {
+        whichKey.enable = true;
+        cheatsheet.enable = true;
+      };
+
+      telescope.enable = true;
+
+      git = {
+        enable = true;
+        gitsigns.enable = true;
+        gitsigns.codeActions.enable = false; # throws an annoying debug message
+      };
+
+      minimap = {
+        minimap-vim.enable = false;
+        codewindow.enable = isMaximal; # lighter, faster, and uses lua for configuration
+      };
+
+      dashboard = {
+        dashboard-nvim.enable = false;
+        alpha.enable = isMaximal;
+      };
+
+      notify = {
+        nvim-notify.enable = true;
+      };
+
+      projects = {
+        project-nvim.enable = isMaximal;
+      };
+
+      utility = {
+        ccc.enable = isMaximal;
+        vim-wakatime.enable = false;
+        icon-picker.enable = isMaximal;
+        surround.enable = isMaximal;
+        diffview-nvim.enable = true;
+        motion = {
+          hop.enable = true;
+          leap.enable = true;
+        };
+
+        images = {
+          image-nvim.enable = false;
+        };
+      };
+
+      notes = {
+        obsidian.enable = false; # FIXME: neovim fails to build if obsidian is enabled
+        orgmode.enable = false;
+        mind-nvim.enable = isMaximal;
+        todo-comments.enable = true;
+      };
+
+      terminal = {
+        toggleterm = {
+          enable = true;
+          lazygit.enable = true;
+        };
+      };
+
+      ui = {
+        borders.enable = true;
+        noice.enable = true;
+        colorizer.enable = true;
+        modes-nvim.enable = false; # the theme looks terrible with catppuccin
+        illuminate.enable = true;
+        breadcrumbs = {
+          enable = isMaximal;
+          navbuddy.enable = isMaximal;
+        };
+        smartcolumn = {
+          enable = true;
+          setupOpts.custom_colorcolumn = {
+            # this is a freeform module, it's `buftype = int;` for configuring column position
+            nix = "110";
+            ruby = "120";
+            java = "130";
+            go = ["90" "130"];
+          };
+        };
+      };
+
+      assistant = {
+        chatgpt.enable = false;
+        copilot = {
+          enable = false;
+          cmp.enable = isMaximal;
+        };
+      };
+
+      session = {
+        nvim-session-manager.enable = false;
+      };
+
+      gestures = {
+        gesture-nvim.enable = false;
+      };
+
+      comments = {
+        comment-nvim.enable = true;
+      };
+
+      presence = {
+        neocord.enable = false;
       };
     };
-
-    session = {
-      nvim-session-manager.enable = false;
-    };
-
-    gestures = {
-      gesture-nvim.enable = false;
-    };
-
-    comments = {
-      comment-nvim.enable = true;
-    };
-
-    presence = {
-      neocord.enable = false;
-    };
   };
+in {
+  inherit neovimConfiguration mainConfig;
 }

docs/default.nix

@@ -1,7 +1,7 @@
 {
   inputs,
   pkgs,
-  lib,
+  lib ? import ../lib/stdlib-extended.nix pkgs.lib inputs,
   manpageUrls ? pkgs.path + "/doc/manpage-urls.json",
   ...
 }: let

docs/manual/configuring.md

@@ -5,5 +5,4 @@ configuring/custom-package.md
 configuring/custom-plugins.md
 configuring/languages.md
 configuring/dags.md
-configuring/dag-entries.md
 ```

docs/manual/configuring/custom-plugins/configuring.md

@@ -1,38 +1,16 @@
 # Configuring {#sec-configuring-plugins}
 
 Just making the plugin to your Neovim configuration available might not always
-be enough. In that case, you can write custom lua config using either
-`config.vim.extraPlugins` (which has the `setup` field) or
-`config.vim.luaConfigRC`. The first option uses an attribute set, which maps DAG
-section names to a custom type, which has the fields `package`, `after`,
-`setup`. They allow you to set the package of the plugin, the sections its setup
-code should be after (note that the `extraPlugins` option has its own DAG
-scope), and the its setup code respectively. For example:
-
-```nix
-config.vim.extraPlugins = 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
-  };
-}
-```
-
-The second option also uses an attribute set, but this one is resolved as a DAG
-directly. The attribute names denote the section names, and the values lua code.
-For example:
+be enough. In that case, you can write custom vimscript or lua config, using
+either `config.vim.configRC` or `config.vim.luaConfigRC` respectively. Both of
+these options are attribute sets, and you need to give the configuration you're
+adding some name, like this:
 
 ```nix
 {
-  # this will create an "aquarium" section in your init.lua with the contents of your custom config
+  # this will create an "aquarium" section in your init.vim with the contents of your custom config
   # which will be *appended* to the rest of your configuration, inside your init.vim
-  config.vim.luaConfigRC.aquarium = "vim.cmd('colorscheme aquiarum')";
+  config.vim.configRC.aquarium = "colorscheme aquiarum";
 }
 ```
 

docs/manual/configuring/dag-entries.md

@@ -1,20 +0,0 @@
-# DAG entries in nvf {#ch-dag-entries}
-
-From the previous chapter, it should be clear that DAGs are useful, because you
-can add code that relies on other code. However, if you don't know what the
-entries are called, it's hard to do that, so here is a list of the internal
-entries in nvf:
-
-`vim.luaConfigRC` (top-level DAG):
-
-1. (`luaConfigPre`) - not a part of the actual DAG, instead, it's simply
-   inserted before the rest of the DAG
-2. `globalsScript` - used to set globals defined in `vim.globals`
-3. `basic` - used to set basic configuration options
-4. `theme` - used to set up the theme, which has to be done before other plugins
-5. `pluginConfigs` - the result of the nested `vim.pluginRC` (internal option,
-   see the [Custom Plugins](/index.xhtml#ch-custom-plugins) page for adding your own
-   plugins) DAG, used to set up internal plugins
-6. `extraPluginConfigs` - the result of `vim.extraPlugins`, which is not a
-   direct DAG, but is converted to, and resolved as one internally
-7. `mappings` - the result of `vim.maps`

docs/manual/configuring/dags.md

@@ -6,8 +6,8 @@ addition for certain options is the [**DAG
 type which is borrowed from home-manager's extended library. This type is most
 used for topologically sorting strings. The DAG type allows the attribute set
 entries to express dependency relations among themselves. This can, for
-example, be used to control the order of configuration sections in your 
-`luaConfigRC`.
+example, be used to control the order of configuration sections in your
+`configRC` or `luaConfigRC`.
 
 The below section, mostly taken from the [home-manager
 manual](https://raw.githubusercontent.com/nix-community/home-manager/master/docs/manual/writing-modules/types.md)

docs/release-notes/rl-0.7.md

@@ -2,28 +2,6 @@
 
 Release notes for release 0.7
 
-## Breaking Changes and Migration Guide {#sec-breaking-changes-and-migration-guide-0-7}
-
-In v0.7 we are removing `vim.configRC` in favor of making `vim.luaConfigRC` the
-top-level DAG, and thereby making the entire configuration Lua based. This
-change introduces a few breaking changes:
-
-[DAG entries in nvf manual]: /index.xhtml#ch-dag-entries
-
-- `vim.configRC` has been removed, which means that you have to convert all of
-  your custom vimscript-based configuration to Lua. As for how to do that, you
-  will have to consult the Neovim documentation and your search engine.
-- After migrating your Vimscript-based configuration to Lua, you might not be
-  able to use the same entry names in `vim.luaConfigRC`, because those have also
-  slightly changed. See the new [DAG entries in nvf manual] for more details.
-
-**Why?**
-
-Neovim being an aggressive refactor of Vim, is designed to be mainly Lua based;
-making good use of its extensive Lua API. Additionally, Vimscript is slow and
-brings unnecessary performance overhead while working with different
-configuration formats.
-
 ## Changelog {#sec-release-0.7-changelog}
 
 [ItsSorae](https://github.com/ItsSorae):
@@ -34,8 +12,8 @@ configuration formats.
 [frothymarrow](https://github.com/frothymarrow):
 
 - Modified type for
-  [](#opt-vim.visuals.fidget-nvim.setupOpts.progress.display.overrides) from
-  `anything` to a `submodule` for better type checking.
+  [vim.visuals.fidget-nvim.setupOpts.progress.display.overrides](#opt-vim.visuals.fidget-nvim.setupOpts.progress.display.overrides)
+  from `anything` to a `submodule` for better type checking.
 
 - Fix null `vim.lsp.mappings` generating an error and not being filtered out.
 
@@ -43,34 +21,21 @@ configuration formats.
   group for `Normal`, `NormalFloat`, `LineNr`, `SignColumn` and optionally
   `NvimTreeNormal` to `none`.
 
-- Fix [](#opt-vim.ui.smartcolumn.setupOpts.custom_colorcolumn) using the wrong
-  type `int` instead of the expected type `string`.
-
-- Fix unused src and version attributes in `buildPlug`.
+- Fix [vim.ui.smartcolumn.setupOpts.custom_colorcolumn](#opt-vim.ui.smartcolumn.setupOpts.custom_colorcolumn)
+  using the wrong type `int` instead of the expected type `string`.
 
 [horriblename](https://github.com/horriblename):
 
 - Fix broken treesitter-context keybinds in visual mode
-- Deprecate use of `__empty` to define empty tables in Lua. Empty attrset are no
+- Deprecate use of `__empty` to define empty tables in lua. Empty attrset are no
   longer filtered and thus should be used instead.
 - Add dap-go for better dap configurations
-- Make noice.nvim customizable
-
-[rust-tools.nvim]: https://github.com/simrat39/rust-tools.nvim
-[rustaceanvim]: https://github.com/mrcjkb/rustaceanvim
-
-- Switch from [rust-tools.nvim] to the more feature-packed [rustaceanvim]. This
-  switch entails a whole bunch of new features and options, so you are
-  recommended to go through rustacean.nvim's README to take a closer look at its
-  features and usage
 
 [jacekpoz](https://github.com/jacekpoz):
 
-[ocaml-lsp]: https://github.com/ocaml/ocaml-lsp
+- Add [ocaml-lsp](https://github.com/ocaml/ocaml-lsp) support.
 
-- Add [ocaml-lsp] support
-
-- Fix "Emac" typo
+- Fix Emac typo
 
 [diniamo](https://github.com/diniamo):
 
@@ -78,46 +43,14 @@ configuration formats.
 
 - Add rustfmt as the default formatter for Rust.
 
-- Enabled the terminal integration of catppuccin for theming Neovim's built-in
-  terminal (this also affects toggleterm).
+- Enabled the terminal integration of catppuccin for theming Neovim's built-in terminal (this also affects toggleterm).
 
 - Migrate bufferline to setupOpts for more customizability
 
 - Use `clangd` as the default language server for C languages
 
-- Expose `lib.nvim.types.pluginType`, which for example allows the user to
-  create abstractions for adding plugins
-
-- Migrate indent-blankline to setupOpts for more customizability. While the
-  plugin's options can now be found under `indentBlankline.setupOpts`, the
-  previous iteration of the module also included out of place/broken options,
-  which have been removed for the time being. These are:
-
-  - `listChar` - this was already unused
-  - `fillChar` - this had nothing to do with the plugin, please configure it
-    yourself by adding `vim.opt.listchars:append({ space = '<char>' })` to your
-    lua configuration
-  - `eolChar` - this also had nothing to do with the plugin, please configure it
-    yourself by adding `vim.opt.listchars:append({ eol = '<char>' })` to your
-    lua configuration
-
-[Neovim documentation on `vim.cmd`]: https://neovim.io/doc/user/lua.html#vim.cmd()
-
-- Make Neovim's configuration file entirely Lua based. This comes with a few
-  breaking changes:
-  - `vim.configRC` has been removed. You will need to migrate your entries to
-    Neovim-compliant Lua code, and add them to `vim.luaConfigRC` instead.
-    Existing vimscript configurations may be preserved in `vim.cmd` functions.
-    Please see [Neovim documentation on `vim.cmd`]
-  - `vim.luaScriptRC` is now the top-level DAG, and the internal `vim.pluginRC`
-    has been introduced for setting up internal plugins. See the "DAG entries in
-    nvf" manual page for more information.
-
 [NotAShelf](https://github.com/notashelf):
 
-[ts-error-translator.nvim]: https://github.com/dmmulroy/ts-error-translator.nvim
-[credo]: https://github.com/rrrene/credo
-
 - Add `deno fmt` as the default Markdown formatter. This will be enabled
   automatically if you have autoformatting enabled, but can be disabled manually
   if you choose to.
@@ -127,17 +60,15 @@ configuration formats.
 
 - Refactor `programs.languages.elixir` to use lspconfig and none-ls for LSP and
   formatter setups respectively. Diagnostics support is considered, and may be
-  added once the [credo] linter has been added to nixpkgs. A pull request is
-  currently open.
+  added once the [credo](https://github.com/rrrene/credo) linter has been added
+  to nixpkgs. A pull request is currently open.
 
 - Remove vim-tidal and friends.
 
 - Clean up Lualine module to reduce theme dependency on Catppuccin, and fixed
   blending issues in component separators.
 
-- Add [ts-ereror-translator.nvim] extension of the TS language module, under
-  `vim.languages.ts.extensions.ts-error-translator` to aid with Typescript
-  development.
-
-- Add [neo-tree.nvim] as an alternative file-tree plugin. It will be available
-  under `vim.filetree.neo-tree`, similar to nvimtree.
+- Add
+  [ts-error-translator.nvim](https://github.com/dmmulroy/ts-error-translator.nvim)
+  extension of the TS language module, under
+  `vim.languages.ts.extensions.ts-error-translator`

flake.lock

@@ -67,21 +67,6 @@
         "type": "github"
       }
     },
-    "mnw": {
-      "locked": {
-        "lastModified": 1720927281,
-        "narHash": "sha256-4Z2FtCuL0lT+sM2gb1JMcXOUkeYrWeYZjjs1HuVTlOs=",
-        "owner": "Gerg-L",
-        "repo": "mnw",
-        "rev": "302b18ddb8498aa9a7e0c01f7026e49d545e6898",
-        "type": "github"
-      },
-      "original": {
-        "owner": "Gerg-L",
-        "repo": "mnw",
-        "type": "github"
-      }
-    },
     "naersk": {
       "inputs": {
         "nixpkgs": [
@@ -129,11 +114,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1721016451,
-        "narHash": "sha256-Cypl9ORr5UjtBsbjXMTJRepTe362yNVrPrntUvHiTaw=",
+        "lastModified": 1719082008,
+        "narHash": "sha256-jHJSUH619zBQ6WdC21fFAlDxHErKVDJ5fpN0Hgx4sjs=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "a14c5d651cee9ed70f9cd9e83f323f1e531002db",
+        "rev": "9693852a2070b398ee123a329e68f0dab5526681",
         "type": "github"
       },
       "original": {
@@ -891,22 +876,6 @@
         "type": "github"
       }
     },
-    "plugin-neo-tree-nvim": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1713050882,
-        "narHash": "sha256-cZwOVpdMT0NCtp6Ha592QA2RzKVS6LhXXcjfDBCQ+0k=",
-        "owner": "nvim-neo-tree",
-        "repo": "neo-tree.nvim",
-        "rev": "22e566aeb075c94f670f34077e05ba95190dfb4a",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nvim-neo-tree",
-        "repo": "neo-tree.nvim",
-        "type": "github"
-      }
-    },
     "plugin-neocord": {
       "flake": false,
       "locked": {
@@ -1484,19 +1453,19 @@
         "type": "github"
       }
     },
-    "plugin-rustaceanvim": {
+    "plugin-rust-tools": {
       "flake": false,
       "locked": {
-        "lastModified": 1720595685,
-        "narHash": "sha256-Mx8pB9ECjFpbfmZPuXfpwoE5pUZ363M53f27ht7MBmA=",
-        "owner": "mrcjkb",
-        "repo": "rustaceanvim",
-        "rev": "047f9c9d8cd2861745eb9de6c1570ee0875aa795",
+        "lastModified": 1704259376,
+        "narHash": "sha256-kFane5ze7VDiOzF7jdmXkr50XQsNvdb+a9HQtybEVE0=",
+        "owner": "simrat39",
+        "repo": "rust-tools.nvim",
+        "rev": "676187908a1ce35ffcd727c654ed68d851299d3e",
         "type": "github"
       },
       "original": {
-        "owner": "mrcjkb",
-        "repo": "rustaceanvim",
+        "owner": "simrat39",
+        "repo": "rust-tools.nvim",
         "type": "github"
       }
     },
@@ -1812,7 +1781,6 @@
       "inputs": {
         "flake-parts": "flake-parts",
         "flake-utils": "flake-utils",
-        "mnw": "mnw",
         "nil": "nil",
         "nixpkgs": "nixpkgs",
         "nmd": "nmd",
@@ -1859,7 +1827,6 @@
         "plugin-mind-nvim": "plugin-mind-nvim",
         "plugin-minimap-vim": "plugin-minimap-vim",
         "plugin-modes-nvim": "plugin-modes-nvim",
-        "plugin-neo-tree-nvim": "plugin-neo-tree-nvim",
         "plugin-neocord": "plugin-neocord",
         "plugin-neodev-nvim": "plugin-neodev-nvim",
         "plugin-noice-nvim": "plugin-noice-nvim",
@@ -1896,7 +1863,7 @@
         "plugin-project-nvim": "plugin-project-nvim",
         "plugin-registers": "plugin-registers",
         "plugin-rose-pine": "plugin-rose-pine",
-        "plugin-rustaceanvim": "plugin-rustaceanvim",
+        "plugin-rust-tools": "plugin-rust-tools",
         "plugin-scrollbar-nvim": "plugin-scrollbar-nvim",
         "plugin-smartcolumn": "plugin-smartcolumn",
         "plugin-sqls-nvim": "plugin-sqls-nvim",

flake.nix

@@ -1,22 +1,19 @@
 {
   description = "A neovim flake with a modular configuration";
   outputs = {
+    nixpkgs,
     flake-parts,
     self,
     ...
-  } @ inputs: let
-    # call the extedended library with `inputs`
-    # inputs is used to get the original standard library, and to pass inputs to the plugin autodiscovery function
-    lib = import ./lib/stdlib-extended.nix inputs;
-  in
-    flake-parts.lib.mkFlake {
-      inherit inputs;
-      specialArgs = {inherit lib;};
-    } {
+  } @ inputs:
+    flake-parts.lib.mkFlake {inherit inputs;} {
       # provide overridable systems
       # https://github.com/nix-systems/nix-systems
       systems = import inputs.systems;
+
       imports = [
+        # add lib to module args
+        {_module.args = {inherit (nixpkgs) lib;};}
         ./flake/apps.nix
         ./flake/legacyPackages.nix
         ./flake/overlays.nix
@@ -25,32 +22,36 @@
 
       flake = {
         lib = {
-          inherit (lib) nvim;
-          inherit (lib.nvim) neovimConfiguration;
+          inherit (import ./lib/stdlib-extended.nix nixpkgs.lib inputs) nvim;
+          inherit (import ./configuration.nix inputs) neovimConfiguration;
         };
 
         homeManagerModules = {
           neovim-flake =
-            lib.warn ''
+            nixpkgs.lib.warn ''
               homeManagerModules.neovim-flake has been deprecated.
               Plese use the homeManagerModules.nvf instead
             ''
             self.homeManagerModules.nvf;
 
-          nvf = import ./flake/modules/home-manager.nix self.packages lib;
+          nvf = {
+            imports = [(import ./flake/modules/home-manager.nix self.packages inputs)];
+          };
 
           default = self.homeManagerModules.nvf;
         };
 
         nixosModules = {
           neovim-flake =
-            lib.warn ''
+            nixpkgs.lib.warn ''
               nixosModules.neovim-flake has been deprecated.
               Please use the nixosModules.nvf instead
             ''
             self.nixosModules.nvf;
 
-          nvf = import ./flake/modules/nixos.nix self.packages lib;
+          nvf = {
+            imports = [(import ./flake/modules/nixos.nix self.packages inputs)];
+          };
 
           default = self.nixosModules.nvf;
         };
@@ -65,9 +66,9 @@
         formatter = pkgs.alejandra;
         devShells = {
           default = self'.devShells.lsp;
-          nvim-nix = pkgs.mkShell {packages = [config.packages.nix];};
+          nvim-nix = pkgs.mkShell {nativeBuildInputs = [config.packages.nix];};
           lsp = pkgs.mkShell {
-            packages = with pkgs; [nil statix deadnix alejandra];
+            nativeBuildInputs = with pkgs; [nil statix deadnix alejandra];
           };
         };
       };
@@ -81,9 +82,6 @@
     flake-utils.url = "github:numtide/flake-utils";
     systems.url = "github:nix-systems/default";
 
-    # Alternate neovim-wrapper
-    mnw.url = "github:Gerg-L/mnw";
-
     # For generating documentation website
     nmd = {
       url = "sourcehut:~rycee/nmd";
@@ -165,8 +163,8 @@
       flake = false;
     };
 
-    plugin-rustaceanvim = {
-      url = "github:mrcjkb/rustaceanvim";
+    plugin-rust-tools = {
+      url = "github:simrat39/rust-tools.nvim";
       flake = false;
     };
 
@@ -229,11 +227,6 @@
       flake = false;
     };
 
-    plugin-neo-tree-nvim = {
-      url = "github:nvim-neo-tree/neo-tree.nvim";
-      flake = false;
-    };
-
     # Tablines
     plugin-nvim-bufferline-lua = {
       url = "github:akinsho/nvim-bufferline.lua";

flake/modules/home-manager.nix

@@ -1,7 +1,8 @@
 # Home Manager module
-packages: lib: {
+packages: inputs: {
   config,
   pkgs,
+  lib ? pkgs.lib,
   ...
 }: let
   inherit (lib) maintainers;
@@ -9,10 +10,9 @@ packages: lib: {
   inherit (lib.lists) optional;
   inherit (lib.options) mkOption mkEnableOption literalExpression;
   inherit (lib.types) attrsOf anything bool;
-  inherit (lib.nvim) neovimConfiguration;
-  inherit (lib.nvim.types) anythingConcatLists;
 
   cfg = config.programs.nvf;
+  inherit (import ../../configuration.nix inputs) neovimConfiguration;
 
   neovimConfigured = neovimConfiguration {
     inherit pkgs;
@@ -55,7 +55,7 @@ in {
     };
 
     settings = mkOption {
-      type = attrsOf anythingConcatLists;
+      type = attrsOf anything;
       default = {};
       description = "Attribute set of nvf preferences.";
       example = literalExpression ''
@@ -88,5 +88,4 @@ in {
         ++ optional cfg.enableManpages packages.${pkgs.stdenv.system}.docs-manpages;
     };
   };
-  _file = ./home-manager.nix;
 }

flake/modules/nixos.nix

@@ -1,7 +1,8 @@
 # NixOS module
-packages: lib: {
+packages: inputs: {
   config,
   pkgs,
+  lib ? pkgs.lib,
   ...
 }: let
   inherit (lib) maintainers;
@@ -9,10 +10,9 @@ packages: lib: {
   inherit (lib.lists) optional;
   inherit (lib.options) mkOption mkEnableOption literalExpression;
   inherit (lib.types) attrsOf anything bool;
-  inherit (lib.nvim) neovimConfiguration;
-  inherit (lib.nvim.types) anythingConcatLists;
 
   cfg = config.programs.nvf;
+  inherit (import ../../configuration.nix inputs) neovimConfiguration;
 
   neovimConfigured = neovimConfiguration {
     inherit pkgs;
@@ -55,7 +55,7 @@ in {
     };
 
     settings = mkOption {
-      type = attrsOf anythingConcatLists;
+      type = attrsOf anything;
       default = {};
       description = "Attribute set of nvf preferences.";
       example = literalExpression ''
@@ -88,5 +88,4 @@ in {
         ++ optional cfg.enableManpages packages.${pkgs.stdenv.system}.docs-manpages;
     };
   };
-  _file = ./nixos.nix;
 }

flake/overlays.nix

@@ -1,14 +1,14 @@
 {
+  inputs,
   pkgs,
-  lib,
   ...
 }: let
-  inherit (lib.nvim) neovimConfiguration;
+  inherit (import ../configuration.nix inputs) neovimConfiguration mainConfig;
 
   buildPkg = pkgs: modules: (neovimConfiguration {inherit pkgs modules;}).neovim;
 
-  nixConfig = import ../configuration.nix false;
-  maximalConfig = import ../configuration.nix true;
+  nixConfig = mainConfig false;
+  maximalConfig = mainConfig true;
 in {
   flake.overlays.default = _final: prev: {
     inherit neovimConfiguration;

flake/packages.nix

@@ -1,11 +1,11 @@
 {inputs, ...}: {
   perSystem = {
+    system,
     config,
     pkgs,
-    lib,
     ...
   }: let
-    docs = import ../docs {inherit pkgs inputs lib;};
+    docs = import ../docs {inherit pkgs inputs;};
   in {
     packages = {
       # Documentation

lib/binds.nix

@@ -66,7 +66,7 @@
     mkSetLuaBinding = binding: action:
       mkLuaBinding binding.value action binding.description;
 
-    pushDownDefault = attr: mapAttrs (_: mkDefault) attr;
+    pushDownDefault = attr: mapAttrs (_: value: mkDefault value) attr;
   };
 in
   binds

lib/configuration.nix

@@ -1,18 +0,0 @@
-{
-  inputs,
-  lib,
-}: let
-  modulesWithInputs = import ../modules inputs;
-in
-  {
-    modules ? [],
-    pkgs,
-    check ? true,
-    extraSpecialArgs ? {},
-    extraModules ? [],
-    ...
-  }:
-    modulesWithInputs {
-      inherit pkgs lib check extraSpecialArgs extraModules;
-      configuration.imports = modules;
-    }

lib/dag.nix

@@ -8,10 +8,10 @@
 #  - the addition of the function `entryBefore` indicating a "wanted
 #    by" relationship.
 {lib}: let
-  inherit (builtins) isAttrs attrValues attrNames elem all head tail length toJSON isString;
+  inherit (builtins) isAttrs attrValues attrNames elem all head tail length;
   inherit (lib.attrsets) filterAttrs mapAttrs;
   inherit (lib.lists) toposort;
-  inherit (lib.nvim.dag) empty isEntry entryBetween entryAfter entriesBetween entryAnywhere topoSort;
+  inherit (lib.nvim.dag) empty isEntry entryBetween entryAfter entriesBetween;
 in {
   empty = {};
 
@@ -84,7 +84,7 @@ in {
     normalizedDag =
       mapAttrs (n: v: {
         name = n;
-        inherit (v) data;
+        data = v.data;
         after = v.after ++ dagBefore dag n;
       })
       dag;
@@ -117,6 +117,7 @@ in {
   entriesBetween = tag: let
     go = i: before: after: entries: let
       name = "${tag}-${toString i}";
+      i' = i + 1;
     in
       if entries == []
       then empty
@@ -147,22 +148,8 @@ in {
     ${section.data}
   '';
 
-  resolveDag = {
-    name,
-    dag,
-    mapResult,
-  }: let
-    # When the value is a string, default it to dag.entryAnywhere
-    finalDag = mapAttrs (_: value:
-      if isString value
-      then entryAnywhere value
-      else value)
-    dag;
-    sortedDag = topoSort finalDag;
-    result =
-      if sortedDag ? result
-      then mapResult sortedDag.result
-      else abort ("Dependency cycle in ${name}: " + toJSON sortedDag);
-  in
-    result;
+  mkVimrcSection = section: ''
+    " SECTION: ${section.name}
+    ${section.data}
+  '';
 }

lib/default.nix

@@ -11,5 +11,5 @@
   languages = import ./languages.nix {inherit lib;};
   lists = import ./lists.nix {inherit lib;};
   lua = import ./lua.nix {inherit lib;};
-  neovimConfiguration = import ./configuration.nix {inherit inputs lib;};
+  vim = import ./vim.nix;
 }

lib/lua.nix

@@ -2,9 +2,19 @@
 {lib}: let
   inherit (builtins) hasAttr head throw typeOf isList isAttrs isBool isInt isString isPath isFloat toJSON;
   inherit (lib.attrsets) mapAttrsToList filterAttrs;
-  inherit (lib.strings) concatStringsSep concatMapStringsSep stringToCharacters concatLines;
+  inherit (lib.strings) concatStringsSep concatMapStringsSep stringToCharacters;
   inherit (lib.trivial) boolToString warn;
 in rec {
+  wrapLuaConfig = {
+    luaBefore ? "",
+    luaConfig,
+    luaAfter ? "",
+  }: ''
+    lua << EOF
+    ${concatStringsSep "\n" [luaBefore luaConfig luaAfter]}
+    EOF
+  '';
+
   # Convert a null value to lua's nil
   nullString = value:
     if value == null

lib/stdlib-extended.nix

@@ -1,7 +1,7 @@
 # Convenience function that returns the given Nixpkgs standard library
 # extended with our functions using `lib.extend`.
-inputs:
-inputs.nixpkgs.lib.extend (self: super: {
+nixpkgsLib: inputs:
+nixpkgsLib.extend (self: super: {
   # WARNING: New functions should not be added here, but to files
   # imported by `./default.nix` under their own categories. If your
   # function does not fit to any of the existing categories, create

lib/types/custom.nix

@@ -1,61 +0,0 @@
-{lib}: let
-  inherit (lib) isStringLike showOption showFiles getFiles mergeOneOption mergeEqualOption mkOptionType;
-  inherit (lib.types) anything attrsOf;
-  inherit (lib.nvim.types) anythingConcatLists;
-  inherit (builtins) typeOf isAttrs any head concatLists stringLength;
-in {
-  # HACK: Does this break anything in our case?
-  # A modified version of the nixpkgs anything type that concatenates lists
-  # This isn't the default because the order in which the lists are concatenated depends on the order in which the modules are imported,
-  # which makes it non-deterministic
-  anythingConcatLists =
-    anything
-    // {
-      merge = loc: defs: let
-        getType = value:
-          if isAttrs value && isStringLike value
-          then "stringCoercibleSet"
-          else typeOf value;
-
-        # Throw an error if not all defs have the same type
-        checkType = getType (head defs).value;
-        commonType =
-          if any (def: getType def.value != checkType) defs
-          then throw "The option `${showOption loc}' has conflicting option types in ${showFiles (getFiles defs)}"
-          else checkType;
-
-        mergeFunctions = {
-          # Recursively merge attribute sets
-          set = (attrsOf anythingConcatLists).merge;
-
-          # Overridden behavior for lists, that concatenates lists
-          list = _: defs: concatLists (map (e: e.value) defs);
-
-          # This means it's a package, only accept a single definition
-          stringCoercibleSet = mergeOneOption;
-
-          # This works by passing the argument to the functions,
-          # and merging their returns values instead
-          lambda = loc: defs: arg:
-            anythingConcatLists.merge
-            (loc ++ ["<function body>"])
-            (map (def: {
-                inherit (def) file;
-                value = def.value arg;
-              })
-              defs);
-        };
-      in
-        # Merge the defs with the correct function from above, if available
-        # otherwise only allow equal values
-        (mergeFunctions.${commonType} or mergeEqualOption) loc defs;
-    };
-
-  char = mkOptionType {
-    name = "char";
-    description = "character";
-    descriptionClass = "noun";
-    check = value: stringLength value < 2;
-    merge = mergeEqualOption;
-  };
-}

lib/types/default.nix

@@ -6,10 +6,8 @@
   typesDag = import ./dag.nix {inherit lib;};
   typesPlugin = import ./plugins.nix {inherit inputs lib;};
   typesLanguage = import ./languages.nix {inherit lib;};
-  typesCustom = import ./custom.nix {inherit lib;};
 in {
   inherit (typesDag) dagOf;
-  inherit (typesPlugin) pluginsOpt extraPluginType mkPluginSetupOption luaInline pluginType;
+  inherit (typesPlugin) pluginsOpt extraPluginType mkPluginSetupOption luaInline;
   inherit (typesLanguage) diagnostics mkGrammarOption;
-  inherit (typesCustom) anythingConcatLists char;
 }

lib/types/plugins.nix

@@ -5,7 +5,7 @@
 }: let
   inherit (lib.options) mkOption;
   inherit (lib.attrsets) attrNames mapAttrs' filterAttrs nameValuePair;
-  inherit (lib.strings) hasPrefix removePrefix;
+  inherit (lib.strings) hasPrefix removePrefix isString;
   inherit (lib.types) submodule either package enum str lines attrsOf anything listOf nullOr;
 
   # Get the names of all flake inputs that start with the given prefix.
@@ -52,7 +52,7 @@
     };
   };
 in {
-  inherit extraPluginType fromInputs pluginType;
+  inherit extraPluginType fromInputs;
 
   pluginsOpt = {
     description,

lib/vim.nix

@@ -0,0 +1,26 @@
+let
+  inherit (builtins) isInt isBool toJSON toString;
+in rec {
+  # yes? no.
+  yesNo = value:
+    if value
+    then "yes"
+    else "no";
+
+  # convert a boolean to a vim compliant boolean string
+  mkVimBool = val:
+    if val
+    then "1"
+    else "0";
+
+  # convert a literal value to a vim compliant value
+  valToVim = val:
+    if (isInt val)
+    then (toString val)
+    else
+      (
+        if (isBool val)
+        then (mkVimBool val)
+        else (toJSON val)
+      );
+}

modules/default.nix

@@ -1,28 +1,37 @@
 inputs: {
   configuration,
   pkgs,
-  lib,
+  lib ? pkgs.lib,
   check ? true,
   extraSpecialArgs ? {},
   extraModules ? [],
 }: let
-  inherit (pkgs) vimPlugins;
+  inherit (builtins) map filter isString toString getAttr;
+  inherit (pkgs) wrapNeovimUnstable vimPlugins;
   inherit (pkgs.vimUtils) buildVimPlugin;
-  inherit (lib.strings) isString toString;
-  inherit (lib.lists) filter map concatLists;
-  inherit (lib.attrsets) recursiveUpdate getAttr;
+  inherit (pkgs.neovimUtils) makeNeovimConfig;
+  inherit (lib.strings) makeBinPath escapeShellArgs concatStringsSep;
+  inherit (lib.lists) concatLists optional;
+  inherit (lib.attrsets) recursiveUpdate;
   inherit (lib.asserts) assertMsg;
 
+  # call the extedended library with `lib` and `inputs` as arguments
+  # lib is used to provide the standard library functions to the extended library
+  # but it can be overridden while this file is being called
+  # inputs is used to pass inputs to the plugin autodiscovery function
+  extendedLib = import ../lib/stdlib-extended.nix lib inputs;
+
   # import modules.nix with `check`, `pkgs` and `lib` as arguments
   # check can be disabled while calling this file is called
   # to avoid checking in all modules
   nvimModules = import ./modules.nix {
-    inherit pkgs check lib;
+    inherit pkgs check;
+    lib = extendedLib;
   };
 
   # evaluate the extended library with the modules
   # optionally with any additional modules passed by the user
-  module = lib.evalModules {
+  module = extendedLib.evalModules {
     specialArgs = recursiveUpdate {modulesPath = toString ./.;} extraSpecialArgs;
     modules = concatLists [[configuration] nvimModules extraModules];
   };
@@ -33,23 +42,13 @@ inputs: {
   # build a vim plugin with the given name and arguments
   # if the plugin is nvim-treesitter, warn the user to use buildTreesitterPlug
   # instead
-  buildPlug = {pname, ...} @ attrs: let
-    src = getAttr ("plugin-" + pname) inputs;
-  in
-    pkgs.runCommand "${pname}-${src.shortRev or src.shortDirtyRev or "dirty"}" attrs
-    ''
-      mkdir -p $out
-      cp -r ${src}/. $out
-    '';
-
-  noBuildPlug = {pname, ...} @ attrs: let
-    input = getAttr ("plugin-" + pname) inputs;
-  in
-    {
-      version = input.shortRev or input.shortDirtyRev or "dirty";
-      outPath = getAttr ("plugin-" + pname) inputs;
-    }
-    // attrs;
+  buildPlug = {pname, ...} @ args:
+    assert assertMsg (pname != "nvim-treesitter") "Use buildTreesitterPlug for building nvim-treesitter.";
+      buildVimPlugin (args
+        // {
+          version = "master";
+          src = getAttr ("plugin-" + pname) inputs;
+        });
 
   buildTreesitterPlug = grammars: vimPlugins.nvim-treesitter.withPlugins (_: grammars);
 
@@ -63,14 +62,11 @@ inputs: {
           then (buildTreesitterPlug vimOptions.treesitter.grammars)
           else if (plug == "flutter-tools-patched")
           then
-            (
-              buildPlug
-              {
-                pname = "flutter-tools";
-                patches = [../patches/flutter-tools.patch];
-              }
-            )
-          else noBuildPlug {pname = plug;}
+            (buildPlug {
+              pname = "flutter-tools";
+              patches = [../patches/flutter-tools.patch];
+            })
+          else (buildPlug {pname = plug;})
         )
       else plug
     ))
@@ -82,9 +78,13 @@ inputs: {
   builtStartPlugins = buildConfigPlugins vimOptions.startPlugins;
   builtOptPlugins = map (package: {
     plugin = package;
-    optional = true;
+    optional = false;
   }) (buildConfigPlugins vimOptions.optPlugins);
 
+  # combine built start and optional plugins
+  # into a single list
+  plugins = builtStartPlugins ++ builtOptPlugins;
+
   # additional Lua and Python3 packages, mapped to their respective functions
   # to conform to the format makeNeovimConfig expects. end user should
   # only ever need to pass a list of packages, which are modified
@@ -92,19 +92,29 @@ inputs: {
   extraLuaPackages = ps: map (x: ps.${x}) vimOptions.luaPackages;
   extraPython3Packages = ps: map (x: ps.${x}) vimOptions.python3Packages;
 
-  # Wrap the user's desired (unwrapped) Neovim package with arguments that'll be used to
-  # generate a wrapped Neovim package.
-  neovim-wrapped = inputs.mnw.lib.wrap pkgs {
-    neovim = vimOptions.package;
-    plugins = concatLists [builtStartPlugins builtOptPlugins];
-    appName = "nvf";
-    extraBinPath = vimOptions.extraPackages;
-    initLua = vimOptions.builtLuaConfigRC;
-    luaFiles = vimOptions.extraLuaFiles;
+  extraWrapperArgs =
+    concatStringsSep " " (optional (vimOptions.extraPackages != []) ''--prefix PATH : "${makeBinPath vimOptions.extraPackages}"'');
 
+  # wrap user's desired neovim package with the desired neovim configuration
+  # using wrapNeovimUnstable and makeNeovimConfig from nixpkgs.
+  # the makeNeovimConfig function takes the following arguments:
+  #  - withPython (bool)
+  #  - extraPython3Packages (lambda)
+  #  - withNodeJs (bool)
+  #  - withRuby (bool)
+  #  - extraLuaPackages (lambda)
+  #  - plugins (list)
+  #  - customRC (string)
+  # and returns the wrapped package
+  neovimConfigured = makeNeovimConfig {
     inherit (vimOptions) viAlias vimAlias withRuby withNodeJs withPython3;
-    inherit extraLuaPackages extraPython3Packages;
+    inherit plugins extraLuaPackages extraPython3Packages;
+    customRC = vimOptions.builtConfigRC;
   };
+
+  neovim-wrapped = wrapNeovimUnstable vimOptions.package (recursiveUpdate neovimConfigured {
+    wrapperArgs = escapeShellArgs neovimConfigured.wrapperArgs + " " + extraWrapperArgs;
+  });
 in {
   inherit (module) options config;
   inherit (module._module.args) pkgs;

modules/neovim/init/basic.nix

@@ -5,17 +5,16 @@
 }: let
   inherit (lib.options) mkOption literalExpression;
   inherit (lib.strings) optionalString;
-  inherit (lib.types) enum bool str int;
+  inherit (lib.types) enum bool str int nullOr;
   inherit (lib.nvim.dag) entryAfter;
-  inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim;
 in {
   options.vim = {
     leaderKey = mkOption {
-      type = str;
-      default = " ";
-      description = "The leader key used for `<leader>` mappings";
+      type = nullOr str;
+      default = null;
+      description = "The leader key to be used internally";
     };
 
     colourTerm = mkOption {
@@ -54,6 +53,12 @@ in {
       description = "Enable syntax highlighting";
     };
 
+    mapLeaderSpace = mkOption {
+      type = bool;
+      default = true;
+      description = "Map the space key to leader key";
+    };
+
     useSystemClipboard = mkOption {
       type = bool;
       default = false;
@@ -160,110 +165,117 @@ in {
     };
   };
 
-  config.vim.luaConfigRC.basic = entryAfter ["globalsScript"] ''
-    -- Settings that are set for everything
-    vim.o.encoding = "utf-8"
-    vim.o.hidden = true
-    vim.opt.shortmess:append("c")
-    vim.o.expandtab = true
-    vim.o.mouse = ${toLuaObject cfg.mouseSupport}
-    vim.o.tabstop = ${toLuaObject cfg.tabWidth}
-    vim.o.shiftwidth = ${toLuaObject cfg.tabWidth}
-    vim.o.softtabstop = ${toLuaObject cfg.tabWidth}
-    vim.o.cmdheight = ${toLuaObject cfg.cmdHeight}
-    vim.o.updatetime = ${toLuaObject cfg.updateTime}
-    vim.o.tm = ${toLuaObject cfg.mapTimeout}
-    vim.o.cursorlineopt = ${toLuaObject cfg.cursorlineOpt}
-    vim.o.scrolloff = ${toLuaObject cfg.scrollOffset}
-    vim.g.mapleader = ${toLuaObject cfg.leaderKey}
-    vim.g.maplocalleader = ${toLuaObject cfg.leaderKey}
+  config.vim.configRC.basic = entryAfter ["globalsScript"] ''
+    " Settings that are set for everything
+    set encoding=utf-8
+    set hidden
+    set shortmess+=c
+    set expandtab
+    set mouse=${cfg.mouseSupport}
+    set tabstop=${toString cfg.tabWidth}
+    set shiftwidth=${toString cfg.tabWidth}
+    set softtabstop=${toString cfg.tabWidth}
+    set cmdheight=${toString cfg.cmdHeight}
+    set updatetime=${toString cfg.updateTime}
+    set tm=${toString cfg.mapTimeout}
+    set cursorlineopt=${toString cfg.cursorlineOpt}
+    set scrolloff=${toString cfg.scrollOffset}
 
     ${optionalString cfg.splitBelow ''
-      vim.o.splitbelow = true
+      set splitbelow
     ''}
 
     ${optionalString cfg.splitRight ''
-      vim.o.splitright = true
+      set splitright
     ''}
 
     ${optionalString cfg.showSignColumn ''
-      vim.o.signcolumn = "yes"
+      set signcolumn=yes
     ''}
 
     ${optionalString cfg.autoIndent ''
-      vim.o.autoindent = true
+      set autoindent
     ''}
 
     ${optionalString cfg.preventJunkFiles ''
-      vim.o.swapfile = false
-      vim.o.backup = false
-      vim.o.writebackup = false
+      set noswapfile
+      set nobackup
+      set nowritebackup
     ''}
 
     ${optionalString (cfg.bell == "none") ''
-      vim.o.errorbells = false
-      vim.o.visualbell = false
+      set noerrorbells
+      set novisualbell
     ''}
 
     ${optionalString (cfg.bell == "on") ''
-      vim.o.visualbell = false
+      set novisualbell
     ''}
 
     ${optionalString (cfg.bell == "visual") ''
-      vim.o.errorbells = false
+      set noerrorbells
     ''}
 
     ${optionalString (cfg.lineNumberMode == "relative") ''
-      vim.o.relativenumber = true
+      set relativenumber
     ''}
 
     ${optionalString (cfg.lineNumberMode == "number") ''
-      vim.o.number = true
+      set number
     ''}
 
     ${optionalString (cfg.lineNumberMode == "relNumber") ''
-      vim.o.number = true
-      vim.o.relativenumber = true
+      set number relativenumber
     ''}
 
     ${optionalString cfg.useSystemClipboard ''
-      vim.opt.clipboard:append("unnamedplus")
+      set clipboard+=unnamedplus
+    ''}
+
+    ${optionalString cfg.mapLeaderSpace ''
+      let mapleader=" "
+      let maplocalleader=" "
     ''}
 
     ${optionalString cfg.syntaxHighlighting ''
-      vim.cmd("syntax on")
+      syntax on
     ''}
 
     ${optionalString (!cfg.wordWrap) ''
-      vim.o.wrap = false
+      set nowrap
     ''}
 
     ${optionalString cfg.hideSearchHighlight ''
-      vim.o.hlsearch = false
-      vim.o.incsearch = true
+      set nohlsearch
+      set incsearch
     ''}
 
     ${optionalString cfg.colourTerm ''
-      vim.o.termguicolors = true
+      set termguicolors
+      set t_Co=256
     ''}
 
     ${optionalString (!cfg.enableEditorconfig) ''
-      vim.g.editorconfig = false
+      let g:editorconfig = v:false
+    ''}
+
+    ${optionalString (cfg.leaderKey != null) ''
+      let mapleader = "${toString cfg.leaderKey}"
     ''}
 
     ${optionalString (cfg.searchCase == "ignore") ''
-      vim.o.smartcase = false
-      vim.o.ignorecase = true
+      set nosmartcase
+      set ignorecase
     ''}
 
     ${optionalString (cfg.searchCase == "smart") ''
-      vim.o.smartcase = true
-      vim.o.ignorecase = true
+      set smartcase
+      set ignorecase
     ''}
 
     ${optionalString (cfg.searchCase == "sensitive") ''
-      vim.o.smartcase = false
-      vim.o.ignorecase = false
+      set nosmartcase
+      set noignorecase
     ''}
   '';
 }

modules/neovim/mappings/config.nix

@@ -9,26 +9,32 @@
 in {
   config = {
     vim.maps = {
-      normal = mkIf cfg.disableArrows {
-        "<up>" = {
-          action = "<nop>";
+      normal =
+        mkIf cfg.disableArrows {
+          "<up>" = {
+            action = "<nop>";
 
-          noremap = false;
-        };
-        "<down>" = {
-          action = "<nop>";
+            noremap = false;
+          };
+          "<down>" = {
+            action = "<nop>";
 
-          noremap = false;
+            noremap = false;
+          };
+          "<left>" = {
+            action = "<nop>";
+            noremap = false;
+          };
+          "<right>" = {
+            action = "<nop>";
+            noremap = false;
+          };
+        }
+        // mkIf cfg.mapLeaderSpace {
+          "<space>" = {
+            action = "<nop>";
+          };
         };
-        "<left>" = {
-          action = "<nop>";
-          noremap = false;
-        };
-        "<right>" = {
-          action = "<nop>";
-          noremap = false;
-        };
-      };
 
       insert = mkIf cfg.disableArrows {
         "<up>" = {

modules/plugins/assistant/chatgpt/config.nix

@@ -33,7 +33,7 @@ in {
       startPlugins = [
         "chatgpt"
       ];
-      pluginRC.chagpt = entryAnywhere ''
+      luaConfigRC.chagpt = entryAnywhere ''
         require("chatgpt").setup(${toLuaObject cfg.setupOpts})
       '';
       maps.normal = mkMerge [

modules/plugins/assistant/copilot/config.nix

@@ -30,14 +30,14 @@ in {
         "copilot-lua"
         # cfg.copilotNodePackage
       ]
-      ++ optionals cfg.cmp.enable [
+      ++ optionals (cfg.cmp.enable) [
         "copilot-cmp"
       ];
 
-    vim.pluginRC.copilot = entryAnywhere ''
+    vim.luaConfigRC.copilot = entryAnywhere ''
       require("copilot").setup(${toLuaObject cfg.setupOpts})
 
-      ${lib.optionalString cfg.cmp.enable ''
+      ${lib.optionalString (cfg.cmp.enable) ''
         require("copilot_cmp").setup()
       ''}
     '';

modules/plugins/autopairs/nvim-autopairs/config.nix

@@ -12,7 +12,7 @@ in {
   config = mkIf cfg.enable {
     vim.startPlugins = ["nvim-autopairs"];
 
-    vim.pluginRC.autopairs = entryAnywhere ''
+    vim.luaConfigRC.autopairs = entryAnywhere ''
       require("nvim-autopairs").setup({ map_cr = ${boolToString (!config.vim.autocomplete.enable)} })
     '';
   };

modules/plugins/comments/comment-nvim/config.nix

@@ -41,7 +41,7 @@ in {
       (mkBinding cfg.mappings.toggleSelectedBlock "<Plug>(comment_toggle_blockwise_visual)" mappings.toggleSelectedBlock.description)
     ];
 
-    vim.pluginRC.comment-nvim = entryAnywhere ''
+    vim.luaConfigRC.comment-nvim = entryAnywhere ''
       require('Comment').setup({
         mappings = { basic = false, extra = false, },
       })

modules/plugins/completion/nvim-cmp/config.nix

@@ -186,7 +186,7 @@ in {
 
     # TODO: alternative snippet engines to vsnip
     # https://github.com/hrsh7th/nvim-cmp/blob/main/doc/cmp.txt#L82
-    vim.pluginRC.completion = mkIf (cfg.type == "nvim-cmp") (dagPlacement ''
+    vim.luaConfigRC.completion = mkIf (cfg.type == "nvim-cmp") (dagPlacement ''
       local nvim_cmp_menu_map = function(entry, vim_item)
         -- name for each source
         vim_item.menu = ({

modules/plugins/dashboard/alpha/config.nix

@@ -16,7 +16,7 @@ in {
 
     # the entire credit for this dashboard configuration to https://github.com/Rishabh672003
     # honestly, excellent work
-    vim.pluginRC.alpha = entryAnywhere ''
+    vim.luaConfigRC.alpha = entryAnywhere ''
       local alpha = require("alpha")
       local plenary_path = require("plenary.path")
       local dashboard = require("alpha.themes.dashboard")

modules/plugins/dashboard/dashboard-nvim/config.nix

@@ -13,7 +13,7 @@ in {
       "dashboard-nvim"
     ];
 
-    vim.pluginRC.dashboard-nvim = entryAnywhere ''
+    vim.luaConfigRC.dashboard-nvim = entryAnywhere ''
       require("dashboard").setup{}
     '';
   };

modules/plugins/dashboard/startify/config.nix

@@ -5,6 +5,7 @@
   ...
 }: let
   inherit (lib.modules) mkIf;
+  inherit (lib.nvim.vim) mkVimBool;
 
   cfg = config.vim.dashboard.startify;
 in {
@@ -22,28 +23,28 @@ in {
         else cfg.customFooter;
       "startify_bookmarks" = cfg.bookmarks;
       "startify_lists" = cfg.lists;
-      "startify_change_to_dir" = cfg.changeToDir;
-      "startify_change_to_vcs_root" = cfg.changeToVCRoot;
+      "startify_change_to_dir" = mkVimBool cfg.changeToDir;
+      "startify_change_to_vcs_root" = mkVimBool cfg.changeToVCRoot;
       "startify_change_cmd" = cfg.changeDirCmd;
       "startify_skiplist" = cfg.skipList;
-      "startify_update_oldfiles" = cfg.updateOldFiles;
-      "startify_session_autoload" = cfg.sessionAutoload;
+      "startify_update_oldfiles" = mkVimBool cfg.updateOldFiles;
+      "startify_session_autoload" = mkVimBool cfg.sessionAutoload;
       "startify_commands" = cfg.commands;
       "startify_files_number" = cfg.filesNumber;
       "startify_custom_indices" = cfg.customIndices;
-      "startify_disable_at_vimenter" = cfg.disableOnStartup;
-      "startify_enable_unsafe" = cfg.unsafe;
+      "startify_disable_at_vimenter" = mkVimBool cfg.disableOnStartup;
+      "startify_enable_unsafe" = mkVimBool cfg.unsafe;
       "startify_padding_left" = cfg.paddingLeft;
-      "startify_use_env" = cfg.useEnv;
+      "startify_use_env" = mkVimBool cfg.useEnv;
       "startify_session_before_save" = cfg.sessionBeforeSave;
-      "startify_session_persistence" = cfg.sessionPersistence;
-      "startify_session_delete_buffers" = cfg.sessionDeleteBuffers;
+      "startify_session_persistence" = mkVimBool cfg.sessionPersistence;
+      "startify_session_delete_buffers" = mkVimBool cfg.sessionDeleteBuffers;
       "startify_session_dir" = cfg.sessionDir;
       "startify_skiplist_server" = cfg.skipListServer;
       "startify_session_remove_lines" = cfg.sessionRemoveLines;
       "startify_session_savevars" = cfg.sessionSavevars;
       "startify_session_savecmds" = cfg.sessionSavecmds;
-      "startify_session_sort" = cfg.sessionSort;
+      "startify_session_sort" = mkVimBool cfg.sessionSort;
     };
   };
 }

modules/plugins/dashboard/startify/startify.nix

@@ -1,4 +1,8 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.types) listOf attrs bool enum str oneOf int;
 in {

modules/plugins/debugger/nvim-dap/config.nix

@@ -18,7 +18,7 @@ in {
     (mkIf cfg.enable {
       vim.startPlugins = ["nvim-dap"];
 
-      vim.pluginRC =
+      vim.luaConfigRC =
         {
           # TODO customizable keymaps
           nvim-dap = entryAnywhere ''
@@ -51,7 +51,7 @@ in {
     (mkIf (cfg.enable && cfg.ui.enable) {
       vim.startPlugins = ["nvim-dap-ui" "nvim-nio"];
 
-      vim.pluginRC.nvim-dap-ui = entryAfter ["nvim-dap"] (''
+      vim.luaConfigRC.nvim-dap-ui = entryAfter ["nvim-dap"] (''
           local dapui = require("dapui")
           dapui.setup()
         ''

modules/plugins/filetree/default.nix

@@ -1,6 +1,5 @@
 {
   imports = [
     ./nvimtree
-    ./neo-tree
   ];
 }

modules/plugins/filetree/neo-tree/config.nix

@@ -1,28 +0,0 @@
-{
-  config,
-  lib,
-  ...
-}: let
-  inherit (lib.modules) mkIf;
-  inherit (lib.nvim.dag) entryAnywhere;
-  inherit (lib.nvim.lua) toLuaObject;
-
-  cfg = config.vim.filetree.neo-tree;
-in {
-  config = mkIf cfg.enable {
-    vim = {
-      startPlugins = [
-        # dependencies
-        "plenary-nvim" # commons library
-        "image-nvim" # optional for image previews
-        "nui-nvim" # ui library
-        # neotree
-        "neo-tree-nvim"
-      ];
-
-      pluginRC.neo-tree = entryAnywhere ''
-        require("neo-tree").setup(${toLuaObject cfg.setupOpts})
-      '';
-    };
-  };
-}

modules/plugins/filetree/neo-tree/default.nix

@@ -1,6 +0,0 @@
-{
-  imports = [
-    ./config.nix
-    ./neo-tree.nix
-  ];
-}

modules/plugins/filetree/neo-tree/neo-tree.nix

@@ -1,155 +0,0 @@
-{lib, ...}: let
-  inherit (lib.types) bool str int submodule enum either listOf;
-  inherit (lib.options) mkOption mkEnableOption literalExpression;
-  inherit (lib.nvim.types) mkPluginSetupOption;
-in {
-  options.vim.filetree.neo-tree = {
-    enable = mkEnableOption "filetree via neo-tree.nvim";
-
-    # Permalink:
-    # https://github.com/nvim-neo-tree/neo-tree.nvim/blob/22e566aeb075c94f670f34077e05ba95190dfb4a/lua/neo-tree/defaults.lua
-    setupOpts = mkPluginSetupOption "neo-tree" {
-      add_blank_line_at_top = mkOption {
-        type = bool;
-        default = false;
-        description = ''
-          Whether to add a blank line at the top of the tree
-        '';
-      };
-
-      auto_clean_after_session_restore = mkOption {
-        type = bool;
-        default = false;
-        description = ''
-          Whether to automatically clean up broken neo-tree buffers
-          saved in sessions
-        '';
-      };
-
-      default_source = mkOption {
-        type = str;
-        default = "filesystem";
-        description = ''
-          You can choose a specific source.
-
-          `last` here which indicates the last used source
-        '';
-      };
-
-      enable_diagnostics = mkEnableOption "diagnostics" // {default = true;};
-      enable_git_status = mkEnableOption "git status" // {default = true;};
-      enable_modified_markers = mkEnableOption "markers for files with unsaved changes." // {default = true;};
-      enable_opened_markers =
-        mkEnableOption ''
-          tracking of opened files.
-
-          Required for `components.name.highlight_opened_files`
-        ''
-        // {default = true;};
-
-      enable_refresh_on_write =
-        mkEnableOption ''
-          Refresh the tree when a file is written.
-
-          Only used if `use_libuv_file_watcher` is false.
-        ''
-        // {default = true;};
-
-      enable_cursor_hijack = mkEnableOption ''
-        cursor hijacking.
-
-        If enabled neotree will keep the cursor on the first letter of the filename when moving in the tree
-      '';
-
-      git_status_async = mkEnableOption ''
-        async git status.
-
-        This will make the git status check async and will not block the UI.
-      '';
-
-      /*
-      git_status_async_options = mkOption {
-        description = "These options are for people with VERY large git repos";
-        type = submodule {
-          batch_size = mkOption {
-            type = int;
-            default = 1000;
-            description = "How many lines of git status results to process at a time";
-          };
-
-          batch_delay = mkOption {
-            type = int;
-            default = 10;
-            description = "Delay, in ms, between batches. Spreads out the workload to let other processes run";
-          };
-
-          max_lines = mkOption {
-            type = int;
-            default = 10000;
-            description = ''
-              How many lines of git status results to process.
-
-              Anything after this will be dropped. Anything before this will be used.
-              The last items to be processed are the untracked files.
-            '';
-          };
-        };
-      };
-      */
-
-      hide_root_node = mkOption {
-        type = bool;
-        default = false;
-        description = ''
-          Whether to hide the root node of the tree
-        '';
-      };
-
-      retain_hidden_root_indent = mkOption {
-        type = bool;
-        default = false;
-        description = ''
-          Whether to retain the indent of the hidden root node
-
-          IF the root node is hidden, keep the indentation anyhow.
-          This is needed if you use expanders because they render in the indent.
-        '';
-      };
-
-      log_level = mkOption {
-        type = enum ["trace" "debug" "info" "warn" "error" "fatal"];
-        default = "info";
-        description = "Log level for the plugin.";
-      };
-
-      log_to_file = mkOption {
-        type = either bool str;
-        default = false;
-        example = literalExpression "/tmp/neo-tree.log";
-        description = ''
-          Must be either a boolean or a path to your log file.
-
-          Use :NeoTreeLogs to show the file
-        '';
-      };
-
-      open_files_in_last_window = mkOption {
-        type = bool;
-        default = true;
-        description = ''
-          Whether to open files in the last window
-
-          If disabled, neo-tree will open files in top left window
-        '';
-      };
-
-      open_files_do_not_replace_types = mkOption {
-        type = listOf str;
-        default = ["terminal" "Trouble" "qf" "edgy"];
-        description = ''
-          A list of filetypes that should not be replaced when opening a file
-        '';
-      };
-    };
-  };
-}

modules/plugins/filetree/nvimtree/config.nix

@@ -29,7 +29,7 @@ in {
       "<leader>t" = "+NvimTree";
     };
 
-    vim.pluginRC.nvimtreelua = entryAnywhere ''
+    vim.luaConfigRC.nvimtreelua = entryAnywhere ''
       ${
         optionalString cfg.setupOpts.disable_netrw ''
           -- disable netrew completely

modules/plugins/filetree/nvimtree/default.nix

@@ -1,4 +1,4 @@
-{
+_: {
   imports = [
     ./config.nix
     ./nvimtree.nix

modules/plugins/git/gitsigns/config.nix

@@ -69,7 +69,7 @@ in {
           "<leader>g" = "+Gitsigns";
         };
 
-        pluginRC.gitsigns = entryAnywhere ''
+        luaConfigRC.gitsigns = entryAnywhere ''
           require('gitsigns').setup{}
         '';
       };

modules/plugins/languages/clang.nix

@@ -12,7 +12,7 @@
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.dag) entryAfter;
+  inherit (lib.nvim.dag) entryAnywhere;
 
   packageToCmd = package: defaultCmd:
     if isList cfg.lsp.package
@@ -141,7 +141,7 @@ in {
 
   config = mkIf cfg.enable (mkMerge [
     (mkIf cfg.cHeader {
-      vim.pluginRC.c-header = entryAfter ["basic"] "vim.g.c_syntax_for_h = 1";
+      vim.configRC.c-header = entryAnywhere "let g:c_syntax_for_h = 1";
     })
 
     (mkIf cfg.treesitter.enable {

modules/plugins/languages/dart.nix

@@ -140,7 +140,7 @@ in {
         then ["flutter-tools-patched"]
         else ["flutter-tools"];
 
-      vim.pluginRC.flutter-tools = entryAnywhere ''
+      vim.luaConfigRC.flutter-tools = entryAnywhere ''
         require('flutter-tools').setup {
           lsp = {
             color = { -- show the derived colours for dart variables

modules/plugins/languages/elixir.nix

@@ -113,7 +113,7 @@ in {
 
     (mkIf cfg.elixir-tools.enable {
       vim.startPlugins = ["elixir-tools"];
-      vim.pluginRC.elixir-tools = entryAnywhere ''
+      vim.luaConfigRC.elixir-tools = entryAnywhere ''
         local elixir-tools = require("elixir")
         local elixirls = require("elixir-tools.elixirls")
 

modules/plugins/languages/go.nix

@@ -102,7 +102,7 @@ in {
     (mkIf cfg.dap.enable {
       vim = {
         startPlugins = ["nvim-dap-go"];
-        pluginRC.nvim-dap-go = entryAfter ["nvim-dap"] ''
+        luaConfigRC.nvim-dap-go = entryAfter ["nvim-dap"] ''
           require('dap-go').setup {
             delve = {
               path = '${getExe cfg.dap.package}',

modules/plugins/languages/html.nix

@@ -36,7 +36,7 @@ in {
           grammars = [cfg.treesitter.package];
         };
 
-        pluginRC.html-autotag = mkIf cfg.treesitter.autotagHtml (entryAnywhere ''
+        luaConfigRC.html-autotag = mkIf cfg.treesitter.autotagHtml (entryAnywhere ''
           require('nvim-ts-autotag').setup()
         '');
       };

modules/plugins/languages/lua.nix

@@ -61,7 +61,7 @@ in {
 
       (mkIf cfg.lsp.neodev.enable {
         vim.startPlugins = ["neodev-nvim"];
-        vim.pluginRC.neodev = entryBefore ["lua-lsp"] ''
+        vim.luaConfigRC.neodev = entryBefore ["lua-lsp"] ''
           require("neodev").setup({})
         '';
       })

modules/plugins/languages/nix.nix

@@ -11,6 +11,7 @@
   inherit (lib.strings) optionalString;
   inherit (lib.types) enum either listOf package str;
   inherit (lib.nvim.types) mkGrammarOption diagnostics;
+  inherit (lib.nvim.dag) entryAnywhere;
   inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.languages) diagnosticsToLua;
 
@@ -175,16 +176,8 @@ in {
 
   config = mkIf cfg.enable (mkMerge [
     {
-      vim.pluginRC.nix = ''
-        vim.api.nvim_create_autocmd("FileType", {
-          pattern = "nix",
-          callback = function(opts)
-            local bo = vim.bo[opts.buf]
-            bo.tabstop = 2
-            bo.shiftwidth = 2
-            bo.softtabstop = 2
-          end
-        })
+      vim.configRC.nix = entryAnywhere ''
+        autocmd filetype nix setlocal tabstop=2 shiftwidth=2 softtabstop=2
       '';
     }
 

modules/plugins/languages/rust.nix

@@ -102,7 +102,7 @@ in {
         startPlugins = ["crates-nvim"];
         lsp.null-ls.enable = mkIf cfg.crates.codeActions true;
         autocomplete.sources = {"crates" = "[Crates]";};
-        pluginRC.rust-crates = entryAnywhere ''
+        luaConfigRC.rust-crates = entryAnywhere ''
           require('crates').setup {
             null_ls = {
               enabled = ${boolToString cfg.crates.codeActions},
@@ -125,61 +125,72 @@ in {
 
     (mkIf (cfg.lsp.enable || cfg.dap.enable) {
       vim = {
-        startPlugins = ["rustaceanvim"];
+        startPlugins = ["rust-tools"] ++ optionals cfg.dap.enable [cfg.dap.package];
 
-        luaConfigRC.rustaceanvim = entryAnywhere ''
-          vim.g.rustaceanvim = {
-          ${optionalString cfg.lsp.enable ''
-            -- LSP
-            tools = {
-              hover_actions = {
-                replace_builtin_hover = false
+        lsp.lspconfig = {
+          enable = true;
+          sources.rust-lsp = ''
+            local rt = require('rust-tools')
+            rust_on_attach = function(client, bufnr)
+              default_on_attach(client, bufnr)
+              local opts = { noremap=true, silent=true, buffer = bufnr }
+              vim.keymap.set("n", "<leader>ris", rt.inlay_hints.set, opts)
+              vim.keymap.set("n", "<leader>riu", rt.inlay_hints.unset, opts)
+              vim.keymap.set("n", "<leader>rr", rt.runnables.runnables, opts)
+              vim.keymap.set("n", "<leader>rp", rt.parent_module.parent_module, opts)
+              vim.keymap.set("n", "<leader>rm", rt.expand_macro.expand_macro, opts)
+              vim.keymap.set("n", "<leader>rc", rt.open_cargo_toml.open_cargo_toml, opts)
+              vim.keymap.set("n", "<leader>rg", function() rt.crate_graph.view_crate_graph("x11", nil) end, opts)
+              ${optionalString cfg.dap.enable ''
+              vim.keymap.set("n", "<leader>rd", ":RustDebuggables<cr>", opts)
+              vim.keymap.set(
+                "n", "${config.vim.debugger.nvim-dap.mappings.continue}",
+                function()
+                  local dap = require("dap")
+                  if dap.status() == "" then
+                    vim.cmd "RustDebuggables"
+                  else
+                    dap.continue()
+                  end
+                end,
+                opts
+              )
+            ''}
+            end
+            local rustopts = {
+              tools = {
+                autoSetHints = true,
+                hover_with_actions = false,
+                inlay_hints = {
+                  only_current_line = false,
+                }
               },
-            },
-            server = {
-              cmd = ${
+              server = {
+                capabilities = capabilities,
+                on_attach = rust_on_attach,
+                cmd = ${
               if isList cfg.lsp.package
               then expToLua cfg.lsp.package
               else ''{"${cfg.lsp.package}/bin/rust-analyzer"}''
             },
-              on_attach = function(client, bufnr)
-                default_on_attach(client, bufnr)
-                local opts = { noremap=true, silent=true, buffer = bufnr }
-                vim.keymap.set("n", "<leader>rr", ":RustLsp runnables<CR>", opts)
-                vim.keymap.set("n", "<leader>rp", ":RustLsp parentModule<CR>", opts)
-                vim.keymap.set("n", "<leader>rm", ":RustLsp expandMacro<CR>", opts)
-                vim.keymap.set("n", "<leader>rc", ":RustLsp openCargo", opts)
-                vim.keymap.set("n", "<leader>rg", ":RustLsp crateGraph x11", opts)
-                ${optionalString cfg.dap.enable ''
-              vim.keymap.set("n", "<leader>rd", ":RustLsp debuggables<cr>", opts)
-              vim.keymap.set(
-               "n", "${config.vim.debugger.nvim-dap.mappings.continue}",
-               function()
-                 local dap = require("dap")
-                 if dap.status() == "" then
-                   vim.cmd "RustLsp debuggables"
-                 else
-                   dap.continue()
-                 end
-               end,
-               opts
-              )
-            ''}
-              end
-            },
-          ''}
-
-            ${optionalString cfg.dap.enable ''
-            dap = {
-              adapter = {
-                type = "executable",
-                command = "${cfg.dap.package}/bin/lldb-vscode",
-                name = "rustacean_lldb",
+                settings = {
+                  ${cfg.lsp.opts}
+                }
               },
-            },
-          ''}
-          }
-        '';
+
+              ${optionalString cfg.dap.enable ''
+              dap = {
+                adapter = {
+                  type = "executable",
+                  command = "${cfg.dap.package}/bin/lldb-vscode",
+                  name = "rt_lldb",
+                },
+              },
+            ''}
+            }
+            rt.setup(rustopts)
+          '';
+        };
       };
     })
   ]);

modules/plugins/languages/ts.nix

@@ -20,7 +20,7 @@
   defaultServer = "tsserver";
   servers = {
     tsserver = {
-      package = pkgs.typescript-language-server;
+      package = pkgs.nodePackages.typescript-language-server;
       lspConfig = ''
         lspconfig.tsserver.setup {
           capabilities = capabilities;
@@ -192,7 +192,7 @@ in {
 
     (mkIf cfg.extensions."ts-error-translator".enable {
       vim.startPlugins = ["ts-error-translator"];
-      vim.pluginRC.ts-error-translator = entryAnywhere ''
+      vim.luaConfigRC.ts-error-translator = entryAnywhere ''
         require("ts-error-translator").setup(${toLuaObject cfg.extensions.ts-error-translator.setupOpts})
       '';
     })

modules/plugins/lsp/config.nix

@@ -27,7 +27,7 @@ in {
 
       autocomplete.sources = {"nvim_lsp" = "[LSP]";};
 
-      pluginRC.lsp-setup = ''
+      luaConfigRC.lsp-setup = ''
         vim.g.formatsave = ${boolToString cfg.formatOnSave};
 
         local attach_keymaps = function(client, bufnr)
@@ -103,11 +103,11 @@ in {
           end
         end
 
-        ${optionalString config.vim.ui.breadcrumbs.enable ''local navic = require("nvim-navic")''}
+        ${optionalString (config.vim.ui.breadcrumbs.enable) ''local navic = require("nvim-navic")''}
         default_on_attach = function(client, bufnr)
           attach_keymaps(client, bufnr)
           format_callback(client, bufnr)
-          ${optionalString config.vim.ui.breadcrumbs.enable ''
+          ${optionalString (config.vim.ui.breadcrumbs.enable) ''
           -- let navic attach to buffers
           if client.server_capabilities.documentSymbolProvider then
             navic.attach(client, bufnr)

modules/plugins/lsp/lightbulb/config.nix

@@ -12,7 +12,7 @@ in {
     vim = {
       startPlugins = ["nvim-lightbulb"];
 
-      pluginRC.lightbulb = entryAnywhere ''
+      luaConfigRC.lightbulb = entryAnywhere ''
         vim.api.nvim_command('autocmd CursorHold,CursorHoldI * lua require\'nvim-lightbulb\'.update_lightbulb()')
 
         -- Enable trouble diagnostics viewer

modules/plugins/lsp/lsp-signature/config.nix

@@ -20,7 +20,7 @@ in {
         handler_opts.border = config.vim.ui.borders.plugins.lsp-signature.style;
       };
 
-      pluginRC.lsp-signature = entryAnywhere ''
+      luaConfigRC.lsp-signature = entryAnywhere ''
         -- Enable lsp signature viewer
         require("lsp_signature").setup(${toLuaObject cfg.lspSignature.setupOpts})
       '';

modules/plugins/lsp/lspconfig/config.nix

@@ -17,7 +17,7 @@ in {
 
         startPlugins = ["nvim-lspconfig"];
 
-        pluginRC.lspconfig = entryAfter ["lsp-setup"] ''
+        luaConfigRC.lspconfig = entryAfter ["lsp-setup"] ''
           local lspconfig = require('lspconfig')
 
           ${
@@ -29,7 +29,7 @@ in {
       };
     }
     {
-      vim.pluginRC = mapAttrs (_: v: (entryAfter ["lspconfig"] v)) cfg.lspconfig.sources;
+      vim.luaConfigRC = mapAttrs (_: v: (entryAfter ["lspconfig"] v)) cfg.lspconfig.sources;
     }
   ]);
 }

modules/plugins/lsp/lspkind/config.nix

@@ -10,7 +10,7 @@
 in {
   config = mkIf (cfg.enable && cfg.lspkind.enable) {
     vim.startPlugins = ["lspkind"];
-    vim.pluginRC.lspkind = entryAnywhere ''
+    vim.luaConfigRC.lspkind = entryAnywhere ''
       local lspkind = require'lspkind'
       local lspkind_opts = {
         mode = '${cfg.lspkind.mode}'

modules/plugins/lsp/lsplines/config.nix

@@ -10,7 +10,7 @@
 in {
   config = mkIf (cfg.enable && cfg.lsplines.enable) {
     vim.startPlugins = ["lsp-lines"];
-    vim.pluginRC.lsplines = entryAfter ["lspconfig"] ''
+    vim.luaConfigRC.lsplines = entryAfter ["lspconfig"] ''
       require("lsp_lines").setup()
 
       vim.diagnostic.config({

modules/plugins/lsp/lspsaga/config.nix

@@ -41,7 +41,7 @@ in {
         ];
       };
 
-      pluginRC.lspsaga = entryAnywhere ''
+      luaConfigRC.lspsaga = entryAnywhere ''
         require('lspsaga').init_lsp_saga({
           ${optionalString config.vim.ui.borders.plugins.lspsaga.enable ''
           border_style = '${config.vim.ui.borders.plugins.lspsaga.style}',

modules/plugins/lsp/null-ls/config.nix

@@ -22,7 +22,7 @@ in {
         # since it will hook into LSPs to receive information
         lsp.enable = true;
 
-        pluginRC = {
+        luaConfigRC = {
           # early setup for null-ls
           null_ls-setup = entryAnywhere ''
             local null_ls = require("null-ls")
@@ -46,7 +46,7 @@ in {
       };
     }
     {
-      vim.pluginRC = mapAttrs (_: v: (entryBetween ["null_ls"] ["null_ls-setup"] v)) cfg.null-ls.sources;
+      vim.luaConfigRC = mapAttrs (_: v: (entryBetween ["null_ls"] ["null_ls-setup"] v)) cfg.null-ls.sources;
     }
   ]);
 }

modules/plugins/lsp/nvim-code-action-menu/config.nix

@@ -23,7 +23,7 @@ in {
         "<leader>c" = "+CodeAction";
       };
 
-      pluginRC.code-action-menu = entryAnywhere ''
+      luaConfigRC.code-action-menu = entryAnywhere ''
         -- border configuration
         vim.g.code_action_menu_window_border = '${config.vim.ui.borders.plugins.code-action-menu.style}'
 

modules/plugins/lsp/nvim-docs-view/config.nix

@@ -19,7 +19,7 @@ in {
       lsp.enable = true;
       startPlugins = ["nvim-docs-view"];
 
-      pluginRC.nvim-docs-view = entryAnywhere ''
+      luaConfigRC.nvim-docs-view = entryAnywhere ''
         require("docs-view").setup ${toLuaObject cfg.setupOpts}
       '';
 

modules/plugins/lsp/trouble/config.nix

@@ -32,7 +32,7 @@ in {
         "<leader>lw" = "Workspace";
       };
 
-      pluginRC.trouble = entryAnywhere ''
+      luaConfigRC.trouble = entryAnywhere ''
         -- Enable trouble diagnostics viewer
         require("trouble").setup {}
       '';

modules/plugins/minimap/codewindow/config.nix

@@ -31,7 +31,7 @@ in {
         "<leader>m" = "+Minimap";
       };
 
-      pluginRC.codewindow = entryAnywhere ''
+      luaConfigRC.codewindow = entryAnywhere ''
         local codewindow = require('codewindow')
         codewindow.setup({
           exclude_filetypes = { 'NvimTree', 'orgagenda', 'Alpha'},

modules/plugins/notes/mind-nvim/config.nix

@@ -25,7 +25,7 @@ in {
         "<leader>o" = "+Notes";
       };
 
-      pluginRC.mind-nvim = entryAnywhere ''
+      luaConfigRC.mind-nvim = entryAnywhere ''
         require'mind'.setup()
       '';
     };

modules/plugins/notes/obsidian/config.nix

@@ -22,7 +22,7 @@ in {
         "<leader>o" = "+Notes";
       };
 
-      pluginRC.obsidian = entryAnywhere ''
+      luaConfigRC.obsidian = entryAnywhere ''
         require("obsidian").setup(${toLuaObject cfg.setupOpts})
       '';
     };

modules/plugins/notes/orgmode/config.nix

@@ -21,7 +21,7 @@ in {
           "<leader>o" = "+Notes";
         };
 
-        pluginRC.orgmode = entryAnywhere ''
+        luaConfigRC.orgmode = entryAnywhere ''
           -- Treesitter configuration
           require('nvim-treesitter.configs').setup {
 

modules/plugins/notes/todo-comments/config.nix

@@ -24,7 +24,7 @@ in {
         (mkIf config.vim.lsp.trouble.enable (mkBinding cfg.mappings.trouble ":TodoTrouble<CR>" mappings.trouble.description))
       ];
 
-      pluginRC.todo-comments = ''
+      luaConfigRC.todo-comments = ''
         require('todo-comments').setup(${toLuaObject cfg.setupOpts})
       '';
     };

modules/plugins/projects/project-nvim/config.nix

@@ -14,7 +14,7 @@ in {
       "project-nvim"
     ];
 
-    vim.pluginRC.project-nvim = entryAnywhere ''
+    vim.luaConfigRC.project-nvim = entryAnywhere ''
       require('project_nvim').setup(${toLuaObject cfg.setupOpts})
     '';
   };

modules/plugins/projects/project-nvim/project-nvim.nix

@@ -1,4 +1,8 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkRenamedOptionModule;
   inherit (lib.types) bool listOf str enum;

modules/plugins/rich-presence/neocord/config.nix

@@ -12,7 +12,7 @@ in {
   config = mkIf cfg.enable {
     vim.startPlugins = ["neocord"];
 
-    vim.pluginRC.neocord = entryAnywhere ''
+    vim.luaConfigRC.neocord = entryAnywhere ''
       -- Description of each option can be found in https://github.com/IogaMaster/neocord#lua
       require("neocord").setup(${toLuaObject cfg.setupOpts})
     '';

modules/plugins/session/nvim-session-manager/config.nix

@@ -28,7 +28,7 @@ in {
         # TODO: load_current_dir_session
       ];
 
-      pluginRC.nvim-session-manager = entryAnywhere ''
+      luaConfigRC.nvim-session-manager = entryAnywhere ''
         local Path = require('plenary.path')
         local sm = require('session_manager.config')
         require('session_manager').setup(${toLuaObject cfg.setupOpts})

modules/plugins/spellcheck/vim-dirtytalk/config.nix

@@ -14,7 +14,7 @@ in {
       # vim-dirtytalk doesn't have any setup
       # but we would like to append programming to spelllang
       # as soon as possible while the plugin is enabled
-      pluginRC.vim-dirtytalk = entryAfter ["basic"] ''
+      luaConfigRC.vim-dirtytalk = entryAfter ["basic"] ''
         -- append programming to spelllang
         vim.opt.spelllang:append("programming")
       '';

modules/plugins/statusline/lualine/config.nix

@@ -4,7 +4,7 @@
   ...
 }: let
   inherit (builtins) map;
-  inherit (lib.modules) mkIf mkMerge mkDefault;
+  inherit (lib.modules) mkIf mkMerge;
   inherit (lib.trivial) boolToString;
   inherit (lib.nvim.dag) entryAnywhere;
   inherit (lib.nvim.lua) toLuaObject;
@@ -15,7 +15,7 @@
 in {
   config = mkMerge [
     # TODO: move into nvim-tree file
-    (mkIf config.vim.filetree.nvimTree.enable {
+    (mkIf (config.vim.filetree.nvimTree.enable) {
       vim.statusline.lualine.setupOpts = {
         extensions = ["nvim-tree"];
       };
@@ -23,7 +23,7 @@ in {
     (mkIf (breadcrumbsCfg.enable && breadcrumbsCfg.source == "nvim-navic") {
       vim.statusline.lualine.setupOpts = {
         # TODO: rewrite in new syntax
-        winbar.lualine_c = mkDefault [
+        winbar.lualine_c = [
           [
             "navic"
             (mkLuaInline "draw_empty = ${boolToString config.vim.ui.breadcrumbs.alwaysRender}")
@@ -35,42 +35,42 @@ in {
       vim = {
         startPlugins = ["lualine"];
 
-        pluginRC.lualine = entryAnywhere ''
+        luaConfigRC.lualine = entryAnywhere ''
           local lualine = require('lualine')
           lualine.setup ${toLuaObject cfg.setupOpts}
         '';
 
         # this is for backwards-compatibility
-        # NOTE: since lualine relies heavily on mixed list + key-value table syntax in lua e.g. {1, 2, three = 3}
-        # and we don't have a good syntax for that we're keeping the old options for now
         statusline.lualine.setupOpts = {
           options = {
-            icons_enabled = mkDefault cfg.icons.enable;
-            theme = mkDefault cfg.theme;
-            component_separators = mkDefault [cfg.componentSeparator.left cfg.componentSeparator.right];
-            section_separators = mkDefault [cfg.sectionSeparator.left cfg.sectionSeparator.right];
-            globalstatus = mkDefault cfg.globalStatus;
-            refresh = mkDefault cfg.refresh;
-            always_divide_middle = mkDefault cfg.alwaysDivideMiddle;
+            icons_enabled = cfg.icons.enable;
+            theme = cfg.theme;
+            component_separators = [cfg.componentSeparator.left cfg.componentSeparator.right];
+            section_separators = [cfg.sectionSeparator.left cfg.sectionSeparator.right];
+            globalstatus = cfg.globalStatus;
+            refresh = cfg.refresh;
           };
 
           sections = {
-            lualine_a = mkDefault (map mkLuaInline (cfg.activeSection.a ++ cfg.extraActiveSection.a));
-            lualine_b = mkDefault (map mkLuaInline (cfg.activeSection.b ++ cfg.extraActiveSection.b));
-            lualine_c = mkDefault (map mkLuaInline (cfg.activeSection.c ++ cfg.extraActiveSection.c));
-            lualine_x = mkDefault (map mkLuaInline (cfg.activeSection.x ++ cfg.extraActiveSection.x));
-            lualine_y = mkDefault (map mkLuaInline (cfg.activeSection.y ++ cfg.extraActiveSection.y));
-            lualine_z = mkDefault (map mkLuaInline (cfg.activeSection.z ++ cfg.extraActiveSection.z));
+            lualine_a = map mkLuaInline (cfg.activeSection.a ++ cfg.extraActiveSection.a);
+            lualine_b = map mkLuaInline (cfg.activeSection.b ++ cfg.extraActiveSection.b);
+            lualine_c = map mkLuaInline (cfg.activeSection.c ++ cfg.extraActiveSection.c);
+            lualine_x = map mkLuaInline (cfg.activeSection.x ++ cfg.extraActiveSection.x);
+            lualine_y = map mkLuaInline (cfg.activeSection.y ++ cfg.extraActiveSection.y);
+            lualine_z = map mkLuaInline (cfg.activeSection.z ++ cfg.extraActiveSection.z);
           };
 
           inactive_sections = {
-            lualine_a = mkDefault (map mkLuaInline (cfg.inactiveSection.a ++ cfg.extraInactiveSection.a));
-            lualine_b = mkDefault (map mkLuaInline (cfg.inactiveSection.b ++ cfg.extraInactiveSection.b));
-            lualine_c = mkDefault (map mkLuaInline (cfg.inactiveSection.c ++ cfg.extraInactiveSection.c));
-            lualine_x = mkDefault (map mkLuaInline (cfg.inactiveSection.x ++ cfg.extraInactiveSection.x));
-            lualine_y = mkDefault (map mkLuaInline (cfg.inactiveSection.y ++ cfg.extraInactiveSection.y));
-            lualine_z = mkDefault (map mkLuaInline (cfg.inactiveSection.z ++ cfg.extraInactiveSection.z));
+            lualine_a = map mkLuaInline (cfg.inactiveSection.a ++ cfg.extraInactiveSection.a);
+            lualine_b = map mkLuaInline (cfg.inactiveSection.b ++ cfg.extraInactiveSection.b);
+            lualine_c = map mkLuaInline (cfg.inactiveSection.c ++ cfg.extraInactiveSection.c);
+            lualine_x = map mkLuaInline (cfg.inactiveSection.x ++ cfg.extraInactiveSection.x);
+            lualine_y = map mkLuaInline (cfg.inactiveSection.y ++ cfg.extraInactiveSection.y);
+            lualine_z = map mkLuaInline (cfg.inactiveSection.z ++ cfg.extraInactiveSection.z);
           };
+
+          # probably don't need this?
+          tabline = [];
         };
       };
     })

modules/plugins/tabline/nvim-bufferline/config.nix

@@ -39,7 +39,7 @@ in {
         "<leader>bsi" = "BufferLineSortById";
       };
 
-      pluginRC.nvimBufferline = entryAnywhere ''
+      luaConfigRC.nvimBufferline = entryAnywhere ''
         require("bufferline").setup(${toLuaObject cfg.setupOpts})
       '';
     };

modules/plugins/terminal/toggleterm/config.nix

@@ -23,7 +23,7 @@ in {
 
           maps.normal = mkBinding cfg.mappings.open "<Cmd>execute v:count . \"ToggleTerm\"<CR>" "Toggle terminal";
 
-          pluginRC.toggleterm = entryAnywhere ''
+          luaConfigRC.toggleterm = entryAnywhere ''
             require("toggleterm").setup(${toLuaObject cfg.setupOpts})
           '';
         };
@@ -35,7 +35,7 @@ in {
         vim.startPlugins = optionals (cfg.lazygit.package != null) [
           cfg.lazygit.package
         ];
-        vim.pluginRC.toggleterm-lazygit = entryAfter ["toggleterm"] ''
+        vim.luaConfigRC.toggleterm-lazygit = entryAfter ["toggleterm"] ''
           local terminal = require 'toggleterm.terminal'
           local lazygit = terminal.Terminal:new({
             cmd = '${

modules/plugins/theme/supported_themes.nix

@@ -6,7 +6,10 @@
   inherit (lib.trivial) boolToString warnIf;
 in {
   onedark = {
-    setup = {style ? "dark"}: ''
+    setup = {
+      style ? "dark",
+      transparent,
+    }: ''
       -- OneDark theme
       require('onedark').setup {
         style = "${style}"
@@ -30,7 +33,10 @@ in {
   };
 
   dracula = {
-    setup = {transparent}: ''
+    setup = {
+      style ? null,
+      transparent,
+    }: ''
       require('dracula').setup({
         transparent_bg = ${boolToString transparent},
       });

modules/plugins/theme/theme.nix

@@ -7,10 +7,10 @@
   inherit (lib.attrsets) attrNames;
   inherit (lib.types) bool lines enum;
   inherit (lib.modules) mkIf;
-  inherit (lib.nvim.dag) entryAfter;
+  inherit (lib.nvim.dag) entryBefore;
 
   cfg = config.vim.theme;
-  supportedThemes = import ./supported-themes.nix {
+  supported_themes = import ./supported_themes.nix {
     inherit lib config;
   };
 in {
@@ -21,12 +21,12 @@ in {
     };
 
     name = mkOption {
-      type = enum (attrNames supportedThemes);
-      description = "Supported themes can be found in `supportedThemes.nix`";
+      type = enum (attrNames supported_themes);
+      description = "Supported themes can be found in `supported_themes.nix`";
     };
 
     style = mkOption {
-      type = enum supportedThemes.${cfg.name}.styles;
+      type = enum supported_themes.${cfg.name}.styles;
       description = "Specific style for theme if it supports it";
     };
 
@@ -45,9 +45,11 @@ in {
   config = mkIf cfg.enable {
     vim = {
       startPlugins = [cfg.name];
-      luaConfigRC.theme = entryAfter ["basic"] ''
+      configRC.theme = entryBefore ["luaScript"] ''
+        lua << EOF
         ${cfg.extraConfig}
-        ${supportedThemes.${cfg.name}.setup {inherit (cfg) style transparent;}}
+        ${supported_themes.${cfg.name}.setup (with cfg; {inherit style transparent;})}
+        EOF
       '';
     };
   };

modules/plugins/treesitter/config.nix

@@ -37,18 +37,18 @@ in {
       };
 
       # For some reason treesitter highlighting does not work on start if this is set before syntax on
-      pluginRC.treesitter-fold = mkIf cfg.fold (entryBefore ["basic"] ''
-        -- This is required by treesitter-context to handle folds
-        vim.o.foldmethod = "expr"
-        vim.o.foldexpr = "nvim_treesitter#foldexpr()"
+      configRC.treesitter-fold = mkIf cfg.fold (entryBefore ["basic"] ''
+        " This is required by treesitter-context to handle folds
+        set foldmethod=expr
+        set foldexpr=nvim_treesitter#foldexpr()
 
-        -- This is optional, but is set rather as a sane default.
-        -- If unset, opened files will be folded by automatically as
-        -- the files are opened
-        vim.o.foldenable = false
+        " This is optional, but is set rather as a sane default.
+        " If unset, opened files will be folded by automatically as
+        " the files are opened
+        set nofoldenable
       '');
 
-      pluginRC.treesitter = entryAfter ["basic"] ''
+      luaConfigRC.treesitter = entryAfter ["basic"] ''
         require('nvim-treesitter.configs').setup {
           -- Disable imperative treesitter options that would attempt to fetch
           -- grammars into the read-only Nix store. To add additional grammars here

modules/plugins/treesitter/ts-context/config.nix

@@ -16,7 +16,7 @@ in {
 
       # set up treesitter-context after Treesitter. The ordering
       # should not matter, but there is no harm in doing this
-      pluginRC.treesitter-context = entryAfter ["treesitter"] ''
+      luaConfigRC.treesitter-context = entryAfter ["treesitter"] ''
         require("treesitter-context").setup(${toLuaObject cfg.setupOpts})
       '';
     };

modules/plugins/ui/breadcrumbs/config.nix

@@ -78,7 +78,7 @@ in {
       };
     };
 
-    vim.pluginRC.breadcrumbs = entryAfter ["lspconfig"] ''
+    vim.luaConfigRC.breadcrumbs = entryAfter ["lspconfig"] ''
 
       ${optionalString (cfg.source == "nvim-navic") ''
         local navic = require("nvim-navic")

modules/plugins/ui/colorizer/colorizer.nix

@@ -1,4 +1,8 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkOption mkEnableOption;
   inherit (lib.types) attrsOf enum nullOr submodule bool str;
   inherit (lib.modules) mkRenamedOptionModule;

modules/plugins/ui/colorizer/config.nix

@@ -14,7 +14,7 @@ in {
       "nvim-colorizer-lua"
     ];
 
-    vim.pluginRC.colorizer = entryAnywhere ''
+    vim.luaConfigRC.colorizer = entryAnywhere ''
       require('colorizer').setup(${toLuaObject cfg.setupOpts})
     '';
   };

modules/plugins/ui/illuminate/config.nix

@@ -11,7 +11,7 @@ in {
   config = mkIf cfg.enable {
     vim.startPlugins = ["vim-illuminate"];
 
-    vim.pluginRC.vim-illuminate = entryAnywhere ''
+    vim.luaConfigRC.vim-illuminate = entryAnywhere ''
         require('illuminate').configure({
           filetypes_denylist = {
           'dirvish',

modules/plugins/ui/modes/config.nix

@@ -14,7 +14,7 @@ in {
       "modes-nvim"
     ];
 
-    vim.pluginRC.modes-nvim = entryAnywhere ''
+    vim.luaConfigRC.modes-nvim = entryAnywhere ''
       require('modes').setup(${toLuaObject cfg.setupOpts})
     '';
   };

modules/plugins/ui/noice/config.nix

@@ -6,11 +6,13 @@
 }: let
   inherit (lib.modules) mkIf;
   inherit (lib.lists) optionals;
-  inherit (lib.nvim.lua) toLuaObject;
+  inherit (lib.strings) optionalString;
+  inherit (lib.trivial) boolToString;
   inherit (lib.nvim.dag) entryAnywhere;
 
   cfg = config.vim.ui.noice;
   tscfg = config.vim.treesitter;
+  cmptype = config.vim.autocomplete.type;
 
   defaultGrammars = with pkgs.vimPlugins.nvim-treesitter.builtGrammars; [vim regex lua bash markdown];
 in {
@@ -23,8 +25,68 @@ in {
 
       treesitter.grammars = optionals tscfg.addDefaultGrammars defaultGrammars;
 
-      pluginRC.noice-nvim = entryAnywhere ''
-        require("noice").setup(${toLuaObject cfg.setupOpts})
+      luaConfigRC.noice-nvim = entryAnywhere ''
+        require("noice").setup({
+          lsp = {
+            override = {
+              ["vim.lsp.util.convert_input_to_markdown_lines"] = true,
+              ["vim.lsp.util.stylize_markdown"] = true,
+              ${optionalString (cmptype == "nvim-cmp") "[\"cmp.entry.get_documentation\"] = true,"}
+            },
+
+            signature = {
+              enabled = false, -- FIXME: enabling this file throws an error which I couldn't figure out
+            },
+          },
+
+          hover = {
+            enabled = true,
+            silent = false, -- set to true to not show a message if hover is not available
+            view = nil, -- when nil, use defaults from documentation
+            opts = {}, -- merged with defaults from documentation
+          },
+
+          presets = {
+            bottom_search = true, -- use a classic bottom cmdline for search
+            command_palette = true, -- position the cmdline and popupmenu together
+            long_message_to_split = true, -- long messages will be sent to a split
+            inc_rename = false, -- enables an input dialog for inc-rename.nvim
+            lsp_doc_border = ${boolToString config.vim.ui.borders.enable}, -- add a border to hover docs and signature help
+          },
+
+          format = {
+            cmdline = { pattern = "^:", icon = "", lang = "vim" },
+            search_down = { kind = "search", pattern = "^/", icon = " ", lang = "regex" },
+            search_up = { kind = "search", pattern = "^%?", icon = " ", lang = "regex" },
+            filter = { pattern = "^:%s*!", icon = "", lang = "bash" },
+            lua = { pattern = "^:%s*lua%s+", icon = "", lang = "lua" },
+            help = { pattern = "^:%s*he?l?p?%s+", icon = "󰋖" },
+            input = {},
+          },
+
+          messages = {
+            -- NOTE: If you enable messages, then the cmdline is enabled automatically.
+            -- This is a current Neovim limitation.
+            enabled = true, -- enables the Noice messages UI
+            view = "notify", -- default view for messages
+            view_error = "notify", -- view for errors
+            view_warn = "notify", -- view for warnings
+            view_history = "messages", -- view for :messages
+            view_search = "virtualtext", -- view for search count messages. Set to `false` to disable
+          },
+
+          -- Hide written messages
+          routes = {
+            {
+              filter = {
+                event = "msg_show",
+                kind = "",
+                find = "written",
+              },
+              opts = { skip = true },
+            },
+          },
+        })
       '';
     };
   };

modules/plugins/ui/noice/noice.nix

@@ -1,142 +1,7 @@
-{
-  lib,
-  config,
-  ...
-}: let
-  inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.types) anything nullOr listOf submodule str;
-  inherit (lib.nvim.types) mkPluginSetupOption;
-  inherit (lib.nvim.config) mkBool;
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption;
 in {
   options.vim.ui.noice = {
     enable = mkEnableOption "noice.nvim UI modification library";
-
-    setupOpts = mkPluginSetupOption "noice.nvim" {
-      lsp = {
-        override = {
-          "vim.lsp.util.convert_input_to_markdown_lines" =
-            mkBool true "override the default lsp markdown formatter with Noice";
-
-          "vim.lsp.util.stylize_markdown" =
-            mkBool true "override the lsp markdown formatter with Noice";
-
-          "cmp.entry.get_documentation" =
-            mkBool (config.vim.autocomplete.type == "nvim-cmp") "override cmp documentation with Noice";
-        };
-
-        signature = {
-          enabled = mkEnableOption "signature help";
-        };
-      };
-
-      presets = {
-        bottom_search = mkBool true "use a classic bottom cmdline for search";
-        command_palette = mkBool true "position the cmdline and popupmenu together";
-        long_message_to_split = mkBool true "long messages will be sent to a split";
-        inc_rename = mkBool false "enables an input dialog for inc-rename.nvim";
-        lsp_doc_border =
-          mkBool config.vim.ui.borders.enable "add a border to hover docs and signature help";
-      };
-
-      # TODO: is it possible to write a submodule for this?
-      format = {
-        cmdline = mkOption {
-          description = "formatting options for the cmdline";
-          type = nullOr anything;
-          default = {
-            pattern = "^:";
-            icon = "";
-            lang = "vim";
-          };
-        };
-
-        search_down = mkOption {
-          description = "formatting options for search_down";
-          type = nullOr anything;
-          default = {
-            kind = "search";
-            pattern = "^/";
-            icon = " ";
-            lang = "regex";
-          };
-        };
-
-        search_up = mkOption {
-          description = "formatting options for search_up";
-          type = nullOr anything;
-          default = {
-            kind = "search";
-            pattern = "^%?";
-            icon = " ";
-            lang = "regex";
-          };
-        };
-
-        filter = mkOption {
-          description = "formatting options for filter";
-          type = nullOr anything;
-          default = {
-            pattern = "^:%s*!";
-            icon = "";
-            lang = "bash";
-          };
-        };
-
-        lua = mkOption {
-          description = "formatting options for lua";
-          type = nullOr anything;
-          default = {
-            pattern = "^:%s*lua%s+";
-            icon = "";
-            lang = "lua";
-          };
-        };
-
-        help = mkOption {
-          description = "formatting options for help";
-          type = nullOr anything;
-          default = {
-            pattern = "^:%s*he?l?p?%s+";
-            icon = "󰋖";
-          };
-        };
-      };
-
-      routes = mkOption {
-        description = "How to route messages";
-        type = listOf (submodule {
-          options = {
-            view = mkOption {
-              description = "how this route is viewed";
-              type = nullOr str;
-              default = null;
-            };
-
-            filter = mkOption {
-              description = "a filter for messages matching this route";
-              type = anything;
-            };
-
-            opts = mkOption {
-              description = "options for the view and the route";
-              type = nullOr anything;
-              default = null;
-            };
-          };
-        });
-
-        default = [
-          {
-            filter = {
-              event = "msg_show";
-              kind = "";
-              find = "written";
-            };
-            opts = {skip = true;};
-          }
-        ];
-        defaultText = "Hide written messages";
-      };
-    };
   };
 }

modules/plugins/ui/notifications/nvim-notify/config.nix

@@ -13,7 +13,7 @@ in {
     vim = {
       startPlugins = ["nvim-notify"];
 
-      pluginRC.nvim-notify = entryAnywhere ''
+      luaConfigRC.nvim-notify = entryAnywhere ''
         require('notify').setup(${toLuaObject cfg.setupOpts})
 
         -- required to fix offset_encoding errors

modules/plugins/ui/smartcolumn/config.nix

@@ -13,7 +13,7 @@ in {
     vim = {
       startPlugins = ["smartcolumn"];
 
-      pluginRC.smartcolumn = entryAnywhere ''
+      luaConfigRC.smartcolumn = entryAnywhere ''
         require("smartcolumn").setup(${toLuaObject cfg.setupOpts})
       '';
     };

modules/plugins/ui/smartcolumn/smartcolumn.nix

@@ -1,6 +1,6 @@
 {lib, ...}: let
   inherit (lib.options) mkOption mkEnableOption literalExpression;
-  inherit (lib.types) nullOr str attrsOf either listOf;
+  inherit (lib.types) nullOr int str attrsOf either listOf;
   inherit (lib.modules) mkRenamedOptionModule;
   inherit (lib.nvim.types) mkPluginSetupOption;
 in {

modules/plugins/utility/binds/cheatsheet/cheatsheet.nix

@@ -1,4 +1,8 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkEnableOption;
 in {
   options.vim.binds.cheatsheet = {

modules/plugins/utility/binds/cheatsheet/config.nix

@@ -8,10 +8,10 @@
 
   cfg = config.vim.binds.cheatsheet;
 in {
-  config = mkIf cfg.enable {
+  config = mkIf (cfg.enable) {
     vim.startPlugins = ["cheatsheet-nvim"];
 
-    vim.pluginRC.cheaetsheet-nvim = entryAnywhere ''
+    vim.luaConfigRC.cheaetsheet-nvim = entryAnywhere ''
       require('cheatsheet').setup({})
     '';
   };

modules/plugins/utility/binds/which-key/config.nix

@@ -10,10 +10,10 @@
 
   cfg = config.vim.binds.whichKey;
 in {
-  config = mkIf cfg.enable {
+  config = mkIf (cfg.enable) {
     vim.startPlugins = ["which-key"];
 
-    vim.pluginRC.whichkey = entryAnywhere ''
+    vim.luaConfigRC.whichkey = entryAnywhere ''
       local wk = require("which-key")
       wk.setup ({
         key_labels = {
@@ -23,7 +23,7 @@ in {
           ["<tab>"] = "TAB",
         },
 
-        ${optionalString config.vim.ui.borders.plugins.which-key.enable ''
+        ${optionalString (config.vim.ui.borders.plugins.which-key.enable) ''
         window = {
           border = "${config.vim.ui.borders.plugins.which-key.style}",
         },

modules/plugins/utility/binds/which-key/which-key.nix

@@ -1,4 +1,8 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.types) attrsOf nullOr str;
 in {

modules/plugins/utility/ccc/config.nix

@@ -8,12 +8,12 @@
 
   cfg = config.vim.utility.ccc;
 in {
-  config = mkIf cfg.enable {
+  config = mkIf (cfg.enable) {
     vim.startPlugins = [
       "ccc"
     ];
 
-    vim.pluginRC.ccc = entryAnywhere ''
+    vim.luaConfigRC.ccc = entryAnywhere ''
       local ccc = require("ccc")
       ccc.setup {
       	highlighter = {

modules/plugins/utility/diffview/config.nix

@@ -7,7 +7,7 @@
 
   cfg = config.vim.utility.diffview-nvim;
 in {
-  config = mkIf cfg.enable {
+  config = mkIf (cfg.enable) {
     vim.startPlugins = [
       "diffview-nvim"
       "plenary-nvim"

modules/plugins/utility/gestures/gesture-nvim/config.nix

@@ -25,7 +25,7 @@ in {
       })
     ];
 
-    vim.pluginRC.gesture-nvim = entryAnywhere ''
+    vim.luaConfigRC.gesture-nvim = entryAnywhere ''
       vim.opt.mouse = "a"
 
       local gesture = require("gesture")

modules/plugins/utility/icon-picker/config.nix

@@ -8,13 +8,13 @@
 
   cfg = config.vim.utility.icon-picker;
 in {
-  config = mkIf cfg.enable {
+  config = mkIf (cfg.enable) {
     vim.startPlugins = [
       "icon-picker-nvim"
       "dressing-nvim"
     ];
 
-    vim.pluginRC.icon-picker = entryAnywhere ''
+    vim.luaConfigRC.icon-picker = entryAnywhere ''
       require("icon-picker").setup({
         disable_legacy_commands = true
       })

modules/plugins/utility/images/image-nvim/config.nix

@@ -1,6 +1,7 @@
 {
   config,
   lib,
+  pkgs,
   ...
 }: let
   inherit (lib.modules) mkIf;
@@ -19,7 +20,7 @@ in {
         "magick"
       ];
 
-      pluginRC.image-nvim = entryAnywhere ''
+      luaConfigRC.image-nvim = entryAnywhere ''
         require("image").setup(
           ${toLuaObject cfg.setupOpts}
         )

modules/plugins/utility/images/image-nvim/image-nvim.nix

@@ -1,4 +1,8 @@
-{lib, ...}: let
+{
+  config,
+  lib,
+  ...
+}: let
   inherit (lib.options) mkEnableOption mkOption;
 
   inherit (lib.types) enum listOf str nullOr int;