- Install - · - Configure - · - Docs -
- - - - +# 💤 lazy.nvim **lazy.nvim** is a modern plugin manager for Neovim. @@ -39,9 +7,9 @@ ## ✨ Features - 📦 Manage all your Neovim plugins with a powerful UI -- 🚀 Fast startup times thanks to automatic caching and bytecode compilation of Lua modules +- 🚀 Fast startup times thanks to automatic caching and bytecode compilation of lua modules - 💾 Partial clones instead of shallow clones -- 🔌 Automatic lazy-loading of Lua modules and lazy-loading on events, commands, filetypes, and key mappings +- 🔌 Automatic lazy-loading of lua modules and lazy-loading on events, commands, filetypes, and key mappings - ⏳ Automatically install missing plugins before starting up Neovim, allowing you to start using it right away - 💪 Async execution for improved performance - 🛠️ No need to manually compile plugins @@ -54,16 +22,530 @@ - 🔎 Automatically check for updates - 📋 Commit, branch, tag, version, and full [Semver](https://devhints.io/semver) support - 📈 Statusline component to see the number of pending updates -- 🎨 Automatically lazy-loads colorschemes ## ⚡️ Requirements - Neovim >= **0.8.0** (needs to be built with **LuaJIT**) - Git >= **2.19.0** (for partial clones support) - a [Nerd Font](https://www.nerdfonts.com/) **_(optional)_** -- [luarocks](https://luarocks.org/) to install rockspecs. - You can remove `rockspec` from `opts.pkg.sources` to disable this feature. -## 🚀 Getting Started +## 📦 Installation -Check the [documentation website](https://lazy.folke.io/) for more information. \ No newline at end of file +You can add the following Lua code to your `init.lua` to bootstrap **lazy.nvim** + + + +```lua +local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim" +if not vim.loop.fs_stat(lazypath) then + vim.fn.system({ + "git", + "clone", + "--filter=blob:none", + "--single-branch", + "https://github.com/folke/lazy.nvim.git", + lazypath, + }) +end +vim.opt.runtimepath:prepend(lazypath) +``` + + + +Next step is to add **lazy.nvim** to the top of your `init.lua` + +```lua +require("lazy").setup(plugins, opts) +``` + +- **plugins**: this should be a `table` or a `string` + - `table`: a list with your [Plugin Spec](#-plugin-spec) + - `string`: a Lua module name that contains your [Plugin Spec](#-plugin-spec). See [Structuring Your Plugins](#-structuring-your-plugins) +- **opts**: see [Configuration](#%EF%B8%8F-configuration) **_(optional)_** + +```lua +-- example using a list of specs with the default options +vim.g.mapleader = " " -- make sure to set `mapleader` before lazy so your mappings are correct + +require("lazy").setup({ + "folke/which-key.nvim", + { "folke/neoconf.nvim", cmd = "Neoconf" }, + "folke/neodev.nvim", +}) +``` + +ℹ️ It is recommended to run `:checkhealth lazy` after installation + +## 🔌 Plugin Spec + +| Property | Type | Description | +| ---------------- | ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `[1]` | `string?` | Short plugin url. Will be expanded using `config.git.url_format` | +| **dir** | `string?` | A directory pointing to a local plugin | +| **url** | `string?` | A custom git url where the plugin is hosted | +| **name** | `string?` | A custom name for the plugin used for the local plugin directory and as the display name | +| **dev** | `boolean?` | When `true`, a local plugin directory will be used instead. See `config.dev` | +| **lazy** | `boolean?` | When `true`, the plugin will only be loaded when needed. Lazy-loaded plugins are automatically loaded when their lua modules are `required`, or when one of the laz-loading handlers triggers | +| **enabled** | `boolean?` or `fun():boolean` | When `false`, or if the `function` returns false, then this plugin will not be used | +| **dependencies** | `LazySpec[]` | A list of plugin specs that should be loaded when the plugin loads. Dependencies are always lazy-loaded unless specified otherwise | +| **init** | `fun(LazyPlugin)` | `init` functions are always executed during startup | +| **config** | `fun(LazyPlugin)` | `config` is executed when the plugin loads | +| **build** | `fun(LazyPlugin)` | `build` is executed when a plugin is installed or updated | +| **branch** | `string?` | Branch of the repository | +| **tag** | `string?` | Tag of the repository | +| **commit** | `string?` | Commit of the repository | +| **version** | `string?` | Version to use from the repository. Full [Semver](https://devhints.io/semver) ranges are supported | +| **pin** | `boolean?` | When `true`, this plugin will not be included in updates | +| **event** | `string?` or `string[]` | Lazy-load on event | +| **cmd** | `string?` or `string[]` | Lazy-load on command | +| **ft** | `string?` or `string[]` | Lazy-load on filetype | +| **keys** | `string?` or `string[]` | Lazy-load on key mapping | +| **module** | `false?` | Do not automatically load this lua module when it's required somewhere | + +### Lazy Loading + +**lazy.nvim** automagically lazy-loads Lua modules, so it is not needed to +specify `module=...` everywhere in your plugin specification. This mean that if +you have a plugin `A` that is lazy-loaded and a plugin `B` that requires a +module of plugin `A`, then plugin `A` will be loaded on demand as expected. + +If you don't want this behavior for a certain plugin, you can specify that with `module=false`. +You can then manually load the plugin with `:Lazy load foobar.nvim`. + +You can configure **lazy.nvim** to lazy-load all plugins by default with `config.defaults.lazy = true`. + +Additionally, you can also lazy-load on **events**, **commands**, +**file types** and **key mappings**. + +Plugins will be lazy-loaded when one of the following is `true`: + +- the plugin only exists as a dependency in your spec +- it has an `event`, `cmd`, `ft` or `cmd` key +- it defines an `init` method +- `config.defaults.lazy == true` + +### Versioning + +If you want to install a specific revision of a plugin, you can use `commit`, +`tag`, `branch`, `version`. + +The `version` property supports [Semver](https://semver.org/) ranges. + +
- 
- 
- 
- 
- 
- 
-
+
+
+You can set `config.defaults.version = "*"` to install the latest stable
+version of plugins that support Semver.
+
+### Examples
+
+
+
+```lua
+return {
+ -- the colorscheme should be available when starting Neovim
+ "folke/tokyonight.nvim",
+
+ -- I have a separate config.mappings file where I require which-key.
+ -- With lazy the plugin will be automatically loaded when it is required somewhere
+ { "folke/which-key.nvim", lazy = true },
+
+ {
+ "nvim-neorg/neorg",
+ -- lazy-load on filetype
+ ft = "norg",
+ -- custom config that will be executed when loading the plugin
+ config = function()
+ require("neorg").setup()
+ end,
+ },
+
+ {
+ "dstein64/vim-startuptime",
+ -- lazy-load on a command
+ cmd = "StartupTime",
+ },
+
+ {
+ "hrsh7th/nvim-cmp",
+ -- load cmp on InsertEnter
+ event = "InsertEnter",
+ -- these dependencies will only be loaded when cmp loads
+ -- dependencies are always lazy-loaded unless specified otherwise
+ dependencies = {
+ "hrsh7th/cmp-nvim-lsp",
+ "hrsh7th/cmp-buffer",
+ },
+ config = function()
+ -- ...
+ end,
+ },
+
+ -- you can use the VeryLazy event for things that can
+ -- load later and are not important for the initial UI
+ { "stevearc/dressing.nvim", event = "VeryLazy" },
+
+ {
+ "cshuaimin/ssr.nvim",
+ -- init is always executed during startup, but doesn't load the plugin yet.
+ -- init implies lazy loading
+ init = function()
+ vim.keymap.set({ "n", "x" }, "Click to see some examples
+ +- `*`: latest stable version (this excludes pre-release versions) +- `1.2.x`: any version that starts with `1.2`, such as `1.2.0`, `1.2.3`, etc. +- `^1.2.3`: any version that is compatible with `1.2.3`, such as `1.3.0`, `1.4.5`, etc., but not `2.0.0`. +- `~1.2.3`: any version that is compatible with `1.2.3`, such as `1.2.4`, `1.2.5`, but not `1.3.0`. +- `>1.2.3`: any version that is greater than `1.2.3`, such as `1.3.0`, `1.4.5`, etc. +- `>=1.2.3`: any version that is greater than or equal to `1.2.3`, such as `1.2.3`, `1.3.0`, `1.4.5`, etc. +- `<1.2.3`: any version that is less than `1.2.3`, such as `1.1.0`, `1.0.5`, etc. +- `<=1.2.3`: any version that is less than or equal to `1.2.3`, such as `1.2.3`, `1.1.0`, `1.0.5`, etc + +
+
+
+## 🚀 Usage
+
+Plugins are managed with the `:Lazy` command.
+Open the help with `` to see all the key mappings.
+
+You can press `If you don't want to use a Nerd Font, you can replace the icons with Unicode symbols.
+ +```lua +{ + ui = { + icons = { + cmd = "⌘", + config = "🛠", + event = "📅", + ft = "📂", + init = "⚙", + keys = "🗝", + plugin = "🔌", + runtime = "💻", + source = "📄", + start = "🚀", + task = "📌", + }, + }, +} +``` + +
+
+
+## 🔒 Lockfile `lazy-lock.json`
+
+After every **update**, the local lockfile is updated with the installed revisions.
+It is recommended to have this file under version control.
+
+If you use your Neovim config on multiple machines, using the lockfile, you can
+ensure that the same version of every plugin is installed.
+
+On the other machine, you can do `Lazy restore`, to update all your plugins to
+the version from the lockfile
+
+## ⚡ Performance
+
+Great care has been taken to make the startup code (`lazy.core`) as efficient as possible.
+During startup, all lua files used before `VimEnter` or `BufReadPre` are byte-compiled and cached,
+similar to what [impatient.nvim](https://github.com/lewis6991/impatient.nvim) does.
+
+My config for example loads in about `11ms` with `93` plugins. I do a lot of lazy-loading though :)
+
+**lazy.nvim** comes with an advanced profiler `:Lazy profile` to help you improve performance.
+The profiling view shows you why and how long it took to load your plugins.
+
+
+
+## 🪲 Debug
+
+See an overview of active lazy-loading handlers and what's in the module cache
+
+
+
+## ▶️ Startup Sequence
+
+**lazy.nvim** does **NOT** use Neovim packages and even disables plugin loading
+completely (`vim.go.loadplugins = false`). It takes over the complete
+startup sequence for more flexibility and better performance.
+
+In practice this means that step 10 of [Neovim Initialization](https://neovim.io/doc/user/starting.html#initialization) is done by Lazy:
+
+1. all plugins with `lazy=false` are loaded. This includes sourcing `/plugin` and `/ftdetect` files. (`/after` will not be sourced yet)
+2. all files from `/plugin` and `/ftdetect` directories in you rtp are sourced (excluding `/after`)
+3. all `/after/plugin` files are sourced (this inludes `/after` from plugins)
+4. all the plugins' `init()` functions are executed
+
+Files from runtime directories are always sourced in alphabetical order.
+
+## 📂 Structuring Your Plugins
+
+Some users may want to split their plugin specs in multiple files.
+Instead of passing a spec table to `setup()`, you can use a lua module.
+The specs from the **module** and any **sub-modules** will be merged together in the final spec,
+so it is not needed to add `require` calls in your main plugin file to the other files.
+
+The benefits of using this approach:
+
+- simple to **add** new plugin specs. Just create a new file in your plugins module.
+- allows for **caching** of all your plugin specs. This becomes important if you have a lot of smaller plugin specs.
+- spec changes will automatically be **reloaded** when they're updated, so the `:Lazy` UI is always up to date
+
+Example:
+
+- `~/.config/nvim/init.lua`
+
+```lua
+require("lazy").setup("plugins")
+```
+
+- `~/.config/nvim/lua/plugins.lua` or `~/.config/nvim/lua/plugins/init.lua` **_(this file is optional)_**
+
+```lua
+return {
+ "folke/neodev.nvim",
+ "folke/which-key.nvim",
+ { "folke/neoconf.nvim", cmd = "Neoconf" },
+}
+```
+
+- any lua file in `~/.config/nvim/lua/plugins/*.lua` will be automatically merged in the main plugin spec
+
+For a real-life example, you can check my personal dots:
+
+- [init.lua](https://github.com/folke/dot/blob/master/config/nvim/init.lua) where I require `config.lazy`
+- [config.lazy](https://github.com/folke/dot/blob/master/config/nvim/lua/config/lazy.lua) where I bootstrap and setup **lazy.nvim**
+- [config.plugins](https://github.com/folke/dot/blob/master/config/nvim/lua/config/plugins.lua) is my main plugin config module
+- Any submodule of [config.plugins (submodules)](https://github.com/folke/dot/tree/master/config/nvim/lua/config/plugins) will be automatically loaded as well.
+
+## 📦 Migration Guide
+
+### [packer.nvim](https://github.com/wbthomason/packer.nvim)
+
+- `setup` ➡️ `init`
+- `requires` ➡️ `dependencies`
+- `as` ➡️ `name`
+- `opt` ➡️ `lazy`
+- `run` ➡️ `build`
+- `lock` ➡️ `pin`
+- `module` is auto-loaded. No need to specify
+
+### [paq-nvim](https://github.com/savq/paq-nvim)
+
+- `as` ➡️ `name`
+- `opt` ➡️ `lazy`
+- `run` ➡️ `build`
+
+## ❌ Uninstalling
+
+To uninstall **lazy.nvim**, you need to remove the following files and directories:
+
+- **data**: `~/.local/share/nvim/lazy`
+- **state**: `~/.local/state/nvim/lazy`
+- **lockfile**: `~/.config/nvim/lazy-lock.json`
+
+> paths can differ if you changed `XDG` environment variables.
+
+## 📦 Other Neovim Plugin Managers in Lua
+
+- [packer.nvim](https://github.com/wbthomason/packer.nvim)
+- [paq-nvim](https://github.com/savq/paq-nvim)
+- [neopm](https://github.com/ii14/neopm)
+- [dep](https://github.com/chiyadev/dep)
+- [optpack.nvim](https://github.com/notomo/optpack.nvim)
+- [pact.nvim](https://github.com/rktjmp/pact.nvim)
diff --git a/TODO.md b/TODO.md
index 3d4da4e..5fe44a4 100644
--- a/TODO.md
+++ b/TODO.md
@@ -1,14 +1,4 @@
-# ✅ TODO
-
-- [x] progress bar?
-- [x] options when opening file
-- [x] lazy notify? not ideal when installing missing stuff
-- [x] topmods?
-
-- [ ] better merging options?
-- [ ] especially what to do with merging of handlers?
-- [ ] overwriting keymaps probably doesn't work
-- [ ] disabled deps?
+## ✅ TODO
- [x] fancy UI to manage all your Neovim plugins
- [x] auto lazy-loading of lua modules
@@ -51,23 +41,18 @@
- [ ] add support to specify `engines`, `os` and `cpu` like in `package.json`
- [ ] semver merging. Should check if two or more semver ranges are compatible and calculate the union range
- - default semver merging strategy: if no version matches all, then use the highest version?
+ - default semver merging strategy: if no version matches all, then use highest version?
- [ ] package meta index (package.lua cache for all packages)
-- [x] document highlight groups
-- [x] document user events
-- [x] document API, like lazy.plugins()
-- [x] icons
-
- [x] check in cache if rtp files match
- [x] I think the installation section, specifically the loading part, could use an
extra sentence or two. I was confused on what `config.plugins` was initially.
Maybe a quick, "for example, if you have a lua file
`~/.config/nvim/lua/config/plugins.lua` that returns a table" or something it'd
remove most question marks I think.
-- [x] When auto-installing the plugins the cursor isn't focused on the floating
+- [x] When autoinstalling the plugins the cursor isn't focused on the floating
window, but on the non-floating window in the background.
-- [x] Doing `:Lazy clean` doesn't show which plugins were removed.
+- [ ] Doing `:Lazy clean` doesn't show which plugins were removed.
- [x] Shouldn't the "Versioning" section be in the "Lockfile" chapter?
- [x] Why are personal dotfiles used as examples? Dotfiles change all the time,
there's no guarantee this will be relevant or even exist in two years.
@@ -75,5 +60,5 @@
- [x] Most emojis in "Configuration" aren't shown for me.
- [x] add section on how to uninstall
- [x] add `:Packadd` command or something similar
-- [x] headless install
-- [x] better keys handling
+- [ ] headless install
+- [ ] better keys handling
diff --git a/bootstrap.lua b/bootstrap.lua
deleted file mode 100644
index c934c48..0000000
--- a/bootstrap.lua
+++ /dev/null
@@ -1,51 +0,0 @@
--- Lazy Bootstrapper
--- Usage:
--- ```lua
--- load(vim.fn.system("curl -s https://raw.githubusercontent.com/folke/lazy.nvim/main/bootstrap.lua"))()
--- ```
-local M = {}
-
-function M.setup()
- local uv = vim.uv or vim.loop
- if vim.env.LAZY_STDPATH then
- local root = vim.fn.fnamemodify(vim.env.LAZY_STDPATH, ":p"):gsub("[\\/]$", "")
- for _, name in ipairs({ "config", "data", "state", "cache" }) do
- vim.env[("XDG_%s_HOME"):format(name:upper())] = root .. "/" .. name
- end
- end
-
- if vim.env.LAZY_PATH and not uv.fs_stat(vim.env.LAZY_PATH) then
- vim.env.LAZY_PATH = nil
- end
-
- local lazypath = vim.env.LAZY_PATH or vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
- if not vim.env.LAZY_PATH and not uv.fs_stat(lazypath) then
- vim.api.nvim_echo({
- {
- "Cloning lazy.nvim\n\n",
- "DiagnosticInfo",
- },
- }, true, {})
- local lazyrepo = "https://github.com/folke/lazy.nvim.git"
- local ok, out = pcall(vim.fn.system, {
- "git",
- "clone",
- "--filter=blob:none",
- lazyrepo,
- lazypath,
- })
- if not ok or vim.v.shell_error ~= 0 then
- vim.api.nvim_echo({
- { "Failed to clone lazy.nvim\n", "ErrorMsg" },
- { vim.trim(out or ""), "WarningMsg" },
- { "\nPress any key to exit...", "MoreMsg" },
- }, true, {})
- vim.fn.getchar()
- os.exit(1)
- end
- end
- vim.opt.rtp:prepend(lazypath)
-end
-M.setup()
-
-return M
diff --git a/doc/.keep b/doc/.keep
deleted file mode 100644
index e69de29..0000000
diff --git a/doc/lazy.nvim.txt b/doc/lazy.nvim.txt
index 2ae3b36..e472482 100644
--- a/doc/lazy.nvim.txt
+++ b/doc/lazy.nvim.txt
@@ -1,418 +1,193 @@
-*lazy.nvim.txt* A modern plugin manager for Neovim
+*lazy.nvim.txt* For Neovim >= 0.8.0 Last change: 2022 December 21
==============================================================================
Table of Contents *lazy.nvim-table-of-contents*
-1. 📰 What’s new? |lazy.nvim-📰-what’s-new?|
- - 11.x |lazy.nvim-📰-what’s-new?-11.x|
-2. 🚀 Getting Started |lazy.nvim-🚀-getting-started|
- - ✨ Features |lazy.nvim-🚀-getting-started-✨-features|
- - ⚡️ Requirements |lazy.nvim-🚀-getting-started-⚡️-requirements|
-3. 🛠️ Installation |lazy.nvim-🛠️-installation|
- - Structured Setup |lazy.nvim-🛠️-installation-structured-setup|
- - Single File Setup |lazy.nvim-🛠️-installation-single-file-setup|
-4. 🔌 Plugin Spec |lazy.nvim-🔌-plugin-spec|
- - Spec Source |lazy.nvim-🔌-plugin-spec-spec-source|
- - Spec Loading |lazy.nvim-🔌-plugin-spec-spec-loading|
- - Spec Setup |lazy.nvim-🔌-plugin-spec-spec-setup|
- - Spec Lazy Loading |lazy.nvim-🔌-plugin-spec-spec-lazy-loading|
- - Spec Versioning |lazy.nvim-🔌-plugin-spec-spec-versioning|
- - Spec Advanced |lazy.nvim-🔌-plugin-spec-spec-advanced|
- - Examples |lazy.nvim-🔌-plugin-spec-examples|
- - Lazy Loading |lazy.nvim-🔌-plugin-spec-lazy-loading|
- - Versioning |lazy.nvim-🔌-plugin-spec-versioning|
-5. 📦 Packages |lazy.nvim-📦-packages|
- - Lazy |lazy.nvim-📦-packages-lazy|
- - Rockspec |lazy.nvim-📦-packages-rockspec|
- - Packspec |lazy.nvim-📦-packages-packspec|
-6. ⚙️ Configuration |lazy.nvim-⚙️-configuration|
- - 🌈 Highlight Groups|lazy.nvim-⚙️-configuration-🌈-highlight-groups|
-7. 🚀 Usage |lazy.nvim-🚀-usage|
- - ▶️ Startup Sequence |lazy.nvim-🚀-usage-▶️-startup-sequence|
- - 🚀 Commands |lazy.nvim-🚀-usage-🚀-commands|
- - 📆 User Events |lazy.nvim-🚀-usage-📆-user-events|
- - ❌ Uninstalling |lazy.nvim-🚀-usage-❌-uninstalling|
- - 🔒 Lockfile |lazy.nvim-🚀-usage-🔒-lockfile|
- - 📦 Migration Guide |lazy.nvim-🚀-usage-📦-migration-guide|
- - ⚡ Profiling & Debug |lazy.nvim-🚀-usage-⚡-profiling-&-debug|
- - 📂 Structuring Your Plugins|lazy.nvim-🚀-usage-📂-structuring-your-plugins|
-8. 🔥 Developers |lazy.nvim-🔥-developers|
- - Best Practices |lazy.nvim-🔥-developers-best-practices|
- - Building |lazy.nvim-🔥-developers-building|
- - Minit (Minimal Init) |lazy.nvim-🔥-developers-minit-(minimal-init)|
-9. Links |lazy.nvim-links|
+1. lazy.nvim |lazy.nvim-lazy.nvim|
+ - Features |lazy.nvim-features|
+ - Requirements |lazy.nvim-requirements|
+ - Installation |lazy.nvim-installation|
+ - Plugin Spec |lazy.nvim-plugin-spec|
+ - Configuration |lazy.nvim-configuration|
+ - Usage |lazy.nvim-usage|
+ - Lockfile `lazy-lock.json` |lazy.nvim-lockfile-`lazy-lock.json`|
+ - Performance |lazy.nvim-performance|
+ - 🪲 Debug |lazy.nvim-🪲-debug|
+ - Startup Sequence |lazy.nvim-startup-sequence|
+ - Structuring Your Plugins |lazy.nvim-structuring-your-plugins|
+ - Migration Guide |lazy.nvim-migration-guide|
+ - Uninstalling |lazy.nvim-uninstalling|
+ - Other Neovim Plugin Managers in Lua|lazy.nvim-other-neovim-plugin-managers-in-lua|
==============================================================================
-1. 📰 What’s new? *lazy.nvim-📰-what’s-new?*
-
-
-11.X *lazy.nvim-📰-what’s-new?-11.x*
-
-- **New Website**: There’s a whole new website with a fresh look and improved
- documentation. Check it out at Example of configuring lualine.nvim
+ +```lua +require("lualine").setup({ + sections = { + lualine_x = { + { + require("lazy.status").updates, + cond = require("lazy.status").has_updates, + color = { fg = "#ff9e64" }, + }, + }, + }, +}) + +``` + +
+
+
-✨ FEATURES *lazy.nvim-🚀-getting-started-✨-features*
-
-- 📦 Manage all your Neovim plugins with a powerful UI
-- 🚀 Fast startup times thanks to automatic caching and bytecode compilation of Lua modules
-- 💾 Partial clones instead of shallow clones
-- 🔌 Automatic lazy-loading of Lua modules and lazy-loading on events, commands, filetypes, and key mappings
-- ⏳ Automatically install missing plugins before starting up Neovim, allowing you to start using it right away
-- 💪 Async execution for improved performance
-- 🛠️ No need to manually compile plugins
-- 🧪 Correct sequencing of dependencies
-- 📁 Configurable in multiple files
-- 📚 Generates helptags of the headings in `README.md` files for plugins that don’t have vimdocs
-- 💻 Dev options and patterns for using local plugins
-- 📊 Profiling tools to optimize performance
-- 🔒 Lockfile `lazy-lock.json` to keep track of installed plugins
-- 🔎 Automatically check for updates
-- 📋 Commit, branch, tag, version, and full Semver
+image
+
+
+
-🐛 DEBUG ~
+🪲 DEBUG *lazy.nvim-🪲-debug*
See an overview of active lazy-loading handlers and what’s in the module
-cache.
+cache
+
+
+image
+
+
+
+
+STARTUP SEQUENCE *lazy.nvim-startup-sequence*
+
+**lazy.nvim** does **NOT** use Neovim packages and even disables plugin loading
+completely (`vim.go.loadplugins = false`). It takes over the complete startup
+sequence for more flexibility and better performance.
+
+In practice this means that step 10 of |Neovim Initialization| is done by Lazy:
-📂 STRUCTURING YOUR PLUGINS*lazy.nvim-🚀-usage-📂-structuring-your-plugins*
+1. all plugins with `lazy=false` are loaded. This includes sourcing `/plugin` and `/ftdetect` files. (`/after` will not be sourced yet)
+2. all files from `/plugin` and `/ftdetect` directories in you rtp are sourced (excluding `/after`)
+3. all `/after/plugin` files are sourced (this inludes `/after` from plugins)
+4. all the plugins’ `init()` functions are executed
+
+
+Files from runtime directories are always sourced in alphabetical order.
+
+STRUCTURING YOUR PLUGINS *lazy.nvim-structuring-your-plugins*
Some users may want to split their plugin specs in multiple files. Instead of
-passing a spec table to `setup()`, you can use a Lua module. The specs from the
-**module** and any top-level **sub-modules** will be merged together in the
-final spec, so it is not needed to add `require` calls in your main plugin file
-to the other files.
+passing a spec table to `setup()`, you can use a lua module. The specs from the
+**module** and any **sub-modules** will be merged together in the final spec,
+so it is not needed to add `require` calls in your main plugin file to the
+other files.
The benefits of using this approach:
-- Simple to **add** new plugin specs. Just create a new file in your plugins module.
-- Allows for **caching** of all your plugin specs. This becomes important if you have a lot of smaller plugin specs.
-- Spec changes will automatically be **reloaded** when they’re updated, so the `:Lazy` UI is always up to date.
+
+- simple to **add** new plugin specs. Just create a new file in your plugins module.
+- allows for **caching** of all your plugin specs. This becomes important if you have a lot of smaller plugin specs.
+- spec changes will automatically be **reloaded** when they’re updated, so the `:Lazy` UI is always up to date
+
Example:
+
- `~/.config/nvim/init.lua`
+
>lua
require("lazy").setup("plugins")
<
-- `~/.config/nvim/lua/plugins.lua` or `~/.config/nvim/lua/plugins/init.lua` **(this file is optional)**
+
+
+- `~/.config/nvim/lua/plugins.lua` or `~/.config/nvim/lua/plugins/init.lua` **_(this file is optional)_**
+
>lua
return {
"folke/neodev.nvim",
- "folke/which-key.nvim",
- { "folke/neoconf.nvim", cmd = "Neoconf" },
+ "folke/which-key.nvim",
+ { "folke/neoconf.nvim", cmd = "Neoconf" },
}
<
-- Any lua file in `~/.config/nvim/lua/plugins/*.lua` will be automatically merged in the main plugin spec
-
-For a real-life example, you can check LazyVim
-
+image
+