what will this command do?
Sure, but you need to show me the command first. Drop it in.
mv ~/.config/nvim{,.bak}
This command:
mv ~/.config/nvim{,.bak}
is shorthand for:
mv ~/.config/nvim ~/.config/nvim.bak
What it does:
Renames (moves) your existing Neovim config directory to a backup named nvim.bak. It’s a quick way to disable your current Neovim config without deleting it — often used before testing a fresh config.
clean install nvim on wsl
Here’s a clean, minimal Neovim install for WSL (Ubuntu-based):
mv ~/.config/nvim{,.bak}
mv ~/.local/share/nvim{,.bak}
mv ~/.cache/nvim{,.bak}
sudo apt update
sudo apt install -y ninja-build gettext cmake unzip curl build-essential
curl -LO https://github.com/neovim/neovim/releases/latest/download/nvim.appimage
chmod u+x nvim.appimage
sudo mv nvim.appimage /usr/local/bin/nvim
✅ Run nvim --version to confirm.
mkdir -p ~/.config/nvim
cat < ~/.config/nvim/init.lua
vim.opt.number = true
EOF
nvim
You’re in. Clean. Lean. Ready to layer on plugins if needed.
Want plugin manager or LSP next?
give me nvim keybindings to enable code folding with expr and to navigate/cycle through windows with ctrl + arrow keys
Here’s what you want for code folding and Ctrl+Arrow window movement in init.lua:
vim.o.foldmethod = "expr"
vim.o.foldexpr = "nvim_treesitter#foldexpr()"
vim.o.foldenable = false -- start with folds open
Requires nvim-treesitter installed and configured.
vim.keymap.set('n', '', 'h')
vim.keymap.set('n', '', 'j')
vim.keymap.set('n', '', 'k')
vim.keymap.set('n', '', 'l')
These work in normal mode. For terminal splits or insert mode, you’d need additional mappings if needed.
Want folding to auto-open/close smartly? Want animations? Just say the word.
why this nvim lazy custom plugin is not loading return { “nvim-lualine/lualine.nvim”, event = “VeryLazy”, opts = function(_, opts) – Eviline config for lualine – Author: shadmansaleh – Credit: glepnir local lualine = require(“lualine”)
– Color table for highlights – stylua: ignore local colors = { bg = ‘#202328’, fg = ‘#bbc2cf’, yellow = ‘#ECBE7B’, cyan = ‘#008080’, darkblue = ‘#081633’, green = ‘#98be65’, orange = ‘#FF8800’, violet = ‘#a9a1e1’, magenta = ‘#c678dd’, blue = ‘#51afef’, red = ‘#ec5f67’, }
local conditions = {
buffer_not_empty = function()
return vim.fn.empty(vim.fn.expand("%:t")) ~= 1
end,
hide_in_width = function()
return vim.fn.winwidth(0) > 80
end,
check_git_workspace = function()
local filepath = vim.fn.expand("%:p:h")
local gitdir = vim.fn.finddir(".git", filepath .. ";")
return gitdir and #gitdir > 0 and #gitdir < #filepath
end,
}
-- Config
local config = {
options = {
-- Disable sections and component separators
component_separators = "",
section_separators = "",
theme = {
-- We are going to use lualine_c an lualine_x as left and
-- right section. Both are highlighted by c theme . So we
-- are just setting default looks o statusline
normal = { c = { fg = colors.fg, bg = colors.bg } },
inactive = { c = { fg = colors.fg, bg = colors.bg } },
},
},
sections = {
-- these are to remove the defaults
lualine_a = {},
lualine_b = {},
lualine_y = {},
lualine_z = {},
-- These will be filled later
lualine_c = {},
lualine_x = {},
},
inactive_sections = {
-- these are to remove the defaults
lualine_a = {},
lualine_b = {},
lualine_y = {},
lualine_z = {},
lualine_c = {},
lualine_x = {},
},
}
-- Inserts a component in lualine_c at left section
local function ins_left(component)
table.insert(config.sections.lualine_c, component)
end
-- Inserts a component in lualine_x at right section
local function ins_right(component)
table.insert(config.sections.lualine_x, component)
end
ins_left({
function()
return "▊"
end,
color = { fg = colors.blue }, -- Sets highlighting of component
padding = { left = 0, right = 1 }, -- We don't need space before this
})
ins_left({
-- mode component
function()
return ""
end,
color = function()
-- auto change color according to neovims mode
local mode_color = {
n = colors.red,
i = colors.green,
v = colors.blue,
[""] = colors.blue,
V = colors.blue,
c = colors.magenta,
no = colors.red,
s = colors.orange,
S = colors.orange,
[""] = colors.orange,
ic = colors.yellow,
R = colors.violet,
Rv = colors.violet,
cv = colors.red,
ce = colors.red,
r = colors.cyan,
rm = colors.cyan,
["r?"] = colors.cyan,
["!"] = colors.red,
t = colors.red,
}
return { fg = mode_color[vim.fn.mode()] }
end,
padding = { right = 1 },
})
ins_left({
-- filesize component
"filesize",
cond = conditions.buffer_not_empty,
})
ins_left({
"filename",
cond = conditions.buffer_not_empty,
color = { fg = colors.magenta, gui = "bold" },
})
ins_left({ "location" })
ins_left({ "progress", color = { fg = colors.fg, gui = "bold" } })
ins_left({
"diagnostics",
sources = { "nvim_diagnostic" },
symbols = { error = " ", warn = " ", info = " " },
diagnostics_color = {
error = { fg = colors.red },
warn = { fg = colors.yellow },
info = { fg = colors.cyan },
},
})
-- Insert mid section. You can make any number of sections in neovim :)
-- for lualine it's any number greater then 2
ins_left({
function()
return "%="
end,
})
ins_left({
-- Lsp server name .
function()
local msg = "No Active Lsp"
local buf_ft = vim.api.nvim_get_option_value("filetype", { buf = 0 })
local clients = vim.lsp.get_clients()
if next(clients) == nil then
return msg
end
for _, client in ipairs(clients) do
local filetypes = client.config.filetypes
if filetypes and vim.fn.index(filetypes, buf_ft) ~= -1 then
return client.name
end
end
return msg
end,
icon = " LSP:",
color = { fg = "#ffffff", gui = "bold" },
})
-- Add components to right sections
ins_right({
"o:encoding", -- option component same as &encoding in viml
fmt = string.upper, -- I'm not sure why it's upper case either ;)
cond = conditions.hide_in_width,
color = { fg = colors.green, gui = "bold" },
})
ins_right({
"fileformat",
fmt = string.upper,
icons_enabled = false, -- I think icons are cool but Eviline doesn't have them. sigh
color = { fg = colors.green, gui = "bold" },
})
ins_right({
"branch",
icon = "",
color = { fg = colors.violet, gui = "bold" },
})
ins_right({
"diff",
-- Is it me or the symbol for modified us really weird
symbols = { added = " ", modified = " ", removed = " " },
diff_color = {
added = { fg = colors.green },
modified = { fg = colors.orange },
removed = { fg = colors.red },
},
cond = conditions.hide_in_width,
})
ins_right({
function()
return "▊"
end,
color = { fg = colors.blue },
padding = { left = 1 },
})
table.insert(opts.sections.lualine_x, {
function()
return "" --TODO: add word count
end,
})
-- Now don't forget to initialize lualine
lualine.setup(config) end, } # ChatGPT You're using `opts = function(_, opts)` with full custom setup logic — but you're also calling `lualine.setup(config)` manually inside it.
This conflicts with how Lazy.nvim expects to manage plugin options. If you use opts = ..., Lazy will automatically call the plugin’s setup(opts) behind the scenes — so your lualine.setup(config) is ignored or possibly called too early/late, depending on how lazy loading resolves.
opts = function()
local config = {
-- your whole config table goes here
}
-- remove `lualine.setup(config)` call!
return config
end
Let Lazy.nvim call require("lualine").setup(opts) for you.
config = function()
local lualine = require("lualine")
local config = {
-- your config
}
lualine.setup(config)
end
Use this if you want full control over execution timing.
event = "VeryLazy" is fine, but make sure something actually triggers it.nvim-treesitter is installed and configured, since you’re using its foldexpr indirectly.:Lazy profile to see if the plugin is loaded or skipped.Let me know if you want this rewritten into a clean config = function() block.
i removed the call but it seems that now the plugin is totally ignored
Good instinct removing the setup() call — but now it sounds like Lazy isn’t triggering the plugin at all. Here’s how to debug this precisely:
Run:
:Lazy
Look for lualine.nvim:
event = "VeryLazy" trigger.Try:
event = "UIEnter",
or even
lazy = false, -- forces eager load
"VeryLazy" only fires after all other startup UI events. Depending on your Lazy config, this can be too late — your opts may be ignored if Lazy never thinks it needs to load the plugin.
Try this pared-down working version first:
{
"nvim-lualine/lualine.nvim",
event = "UIEnter",
opts = {
options = {
theme = "gruvbox",
section_separators = '',
component_separators = '',
},
},
}
If that works, your plugin load logic is fine — the issue is inside your opts = function() block.
Add a debug print:
opts = function()
print("lualine opts being applied")
return {
-- your config
}
end
If you don’t see the message, then opts is never run = plugin never loads.
VeryLazy + opts = plugin never initializes.event = "UIEnter" or remove event entirely (lazy = false).:Lazy, and log inside opts.Want me to rewrite your config using config = function() instead?
event = “UIEnter”, made my lualine disappear!
Perfect — this confirms lualine is loading, but your custom config is breaking it.
Here’s the root issue:
You’re using opts = function() with custom logic that builds a config table, but you’re not returning it.
opts = function(_, opts)
local config = {
options = { ... },
sections = { ... },
}
-- config built here...
-- BUT NEVER RETURNED 👎
end
So opts ends up being nil, and Lazy passes that to lualine.setup() → nothing gets rendered.
opts = function()
local config = {
options = {
theme = "gruvbox",
component_separators = "",
section_separators = "",
},
sections = {
lualine_c = { "filename" },
lualine_x = { "filetype" },
},
}
return config
end
opts = function()
local config = {}
-- ... your logic
return config -- 🔥 don't forget this
end
Want me to refactor your full opts = function() block into a clean version that loads correctly?