From Zero to Killer Neovim on Fedora 42 (Rust-Edition)

-

 If you want a vanilla-leaning Neovim that feels stock but has full language features, debugging, tests, Git, fuzzy search, completions, keybinding help, AI, statusline, spell-check, and developer fonts—this is it. We’ll use native LSP, Treesitter, lazy.nvim for plugin management, and a short, readable config. Rust is first-class; Python, TypeScript/CDK, and Bash get the same baseline.


 

1) System prerequisites (Fedora 42)

# Core editor + search tools + build deps
sudo dnf install -y neovim git ripgrep fd-find curl wget unzip cmake gcc-c++ make python3 python3-pip nodejs npm

# Rust toolchain via rustup (recommended)
sudo dnf install -y rustup
rustup toolchain install stable
rustup default stable
rustup component add rustfmt clippy

# rust-analyzer (prefer rustup component if available; else use Fedora package)
rustup component add rust-analyzer || sudo dnf install -y rust-analyzer

# Optional: shells/linters/formatters used later
sudo dnf install -y shellcheck shfmt

Neovim ships with a built-in LSP client, so we’ll not add external LSP frameworks. (Neovim)

2) Developer fonts (Nerd Font + ligatures)

Install a Nerd Font (icons for statusline/git signs/fuzzy UI). JetBrains Mono Nerd Font is a great default.

mkdir -p ~/.local/share/fonts ~/.config/fontconfig/conf.d
cd /tmp
# Download a Nerd Font release zip (choose JetBrainsMono Nerd Font from nerdfonts.com releases)
# Example (update the URL to the latest release if needed):
wget -O JBMNerd.zip "https://github.com/ryanoasis/nerd-fonts/releases/latest/download/JetBrainsMono.zip"
unzip JBMNerd.zip -d ~/.local/share/fonts
fc-cache -fv

For ligatures (JetBrains Mono already supports), set your terminal to use JetBrainsMono Nerd Font.

3) Directory layout

We’ll keep a clean, minimal layout:

~/.config/nvim/
├─ init.lua
└─ lua/
   └─ plugins/
      ├─ core.lua
      ├─ ui.lua
      ├─ lsp.lua
      ├─ cmp.lua
      ├─ treesitter.lua
      ├─ telescope.lua
      ├─ git.lua
      ├─ statusline.lua
      ├─ rust.lua
      ├─ dap.lua
      ├─ test.lua
      ├─ format.lua
      ├─ keys.lua
      └─ ai.lua

4) Bootstrap the plugin manager (lazy.nvim)

lazy.nvim is modern, fast, and dead simple. (GitHub)

~/.config/nvim/init.lua

-- Bootstrap lazy.nvim
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",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable", lazypath
  })
end
vim.opt.rtp:prepend(lazypath)

-- Sensible defaults: keep close to vanilla
vim.g.mapleader = " "        -- <Space> as leader
vim.o.number = true
vim.o.relativenumber = true
vim.o.termguicolors = true
vim.o.updatetime = 300
vim.o.signcolumn = "yes"
vim.o.clipboard = "unnamedplus"
vim.o.spell = true
vim.o.spelllang = "en_us"

-- Load plugins from lua/plugins/*.lua
require("lazy").setup("plugins", {
  checker = { enabled = true }, -- background plugin update checker off by default; toggle if you like
})

5) Core plugins (minimal, powerful)

Create ~/.config/nvim/lua/plugins/core.lua:

return {
  -- Keybinding helper popup
  { "folke/which-key.nvim", event = "VeryLazy", opts = {} },

  -- LSP, mason, and autoconfig
  { "neovim/nvim-lspconfig" },
  { "williamboman/mason.nvim", build = ":MasonUpdate", opts = {} },
  { "williamboman/mason-lspconfig.nvim", opts = {} },

  -- Completion
  { "hrsh7th/nvim-cmp" },
  { "hrsh7th/cmp-nvim-lsp" },
  { "hrsh7th/cmp-buffer" },
  { "hrsh7th/cmp-path" },
  { "L3MON4D3/LuaSnip", build = "make install_jsregexp", dependencies = { "saadparwaiz1/cmp_luasnip" } },

  -- Treesitter
  { "nvim-treesitter/nvim-treesitter", build = ":TSUpdate" },

  -- Telescope (fuzzy finder)
  { "nvim-lua/plenary.nvim" },
  { "nvim-telescope/telescope.nvim", tag = "0.1.6" },

  -- Git
  { "lewis6991/gitsigns.nvim", opts = {} },

  -- UI / statusline
  { "nvim-lualine/lualine.nvim" },

  -- Diagnostics drawer (optional, extremely useful)
  { "folke/trouble.nvim", opts = {} },

  -- Terminal for quick cargo/pytest/npm
  { "akinsho/toggleterm.nvim", version = "*", opts = {} },
}

  • lazy.nvim install notes and UI are here. (GitHub)

6) Treesitter (syntax, motions, folding)

lua/plugins/treesitter.lua

return {
  "nvim-treesitter/nvim-treesitter",
  opts = {
    ensure_installed = { "lua", "rust", "python", "tsx", "typescript", "json", "bash", "toml", "yaml", "markdown" },
    highlight = { enable = true },
    indent = { enable = true },
  },
}

7) Completion (nvim-cmp)

lua/plugins/cmp.lua

return {
  "hrsh7th/nvim-cmp",
  event = "InsertEnter",
  dependencies = { "hrsh7th/cmp-nvim-lsp", "hrsh7th/cmp-buffer", "hrsh7th/cmp-path", "L3MON4D3/LuaSnip", "saadparwaiz1/cmp_luasnip" },
  config = function()
    local cmp = require("cmp")
    local luasnip = require("luasnip")
    cmp.setup({
      snippet = { expand = function(args) luasnip.lsp_expand(args.body) end },
      mapping = cmp.mapping.preset.insert({
        ["<C-Space>"] = cmp.mapping.complete(),
        ["<CR>"] = cmp.mapping.confirm({ select = true }),
        ["<Tab>"] = cmp.mapping.select_next_item(),
        ["<S-Tab>"] = cmp.mapping.select_prev_item(),
      }),
      sources = cmp.config.sources({
        { name = "nvim_lsp" }, { name = "luasnip" }, { name = "path" }, { name = "buffer" },
      }),
    })
  end,
}

8) Fuzzy search (Telescope)

lua/plugins/telescope.lua

return {
  "nvim-telescope/telescope.nvim",
  dependencies = { "nvim-lua/plenary.nvim" },
  cmd = "Telescope",
  opts = {
    defaults = {
      mappings = { i = { ["<C-j>"] = "move_selection_next", ["<C-k>"] = "move_selection_previous" } },
    },
  },
}

Usage:

  • :Telescope find_files (respects .gitignore)

  • :Telescope live_grep (uses ripgrep)

  • :Telescope buffers, :Telescope help_tags

9) Git integration

lua/plugins/git.lua

return {
  "lewis6991/gitsigns.nvim",
  event = "BufReadPre",
  opts = {
    signs = { add = { text = "▎" }, change = { text = "▎" }, delete = { text = "契" }, topdelete = { text = "契" }, changedelete = { text = "▎" } },
    on_attach = function(bufnr)
      local gs = package.loaded.gitsigns
      local map = function(m, l, r) vim.keymap.set(m, l, r, { buffer = bufnr }) end
      map("n", "]h", gs.next_hunk)
      map("n", "[h", gs.prev_hunk)
      map("n", "<leader>hs", gs.stage_hunk)
      map("n", "<leader>hr", gs.reset_hunk)
      map("n", "<leader>hb", gs.blame_line)
    end,
  },
}

10) Statusline

lua/plugins/statusline.lua

return {
  "nvim-lualine/lualine.nvim",
  dependencies = { "nvim-tree/nvim-web-devicons" },
  opts = {
    options = { theme = "auto", section_separators = "", component_separators = "" },
    sections = {
      lualine_a = { "mode" },
      lualine_b = { "branch", "diff", "diagnostics" },
      lualine_c = { { "filename", path = 1 } },
      lualine_x = { "encoding", "fileformat", "filetype" },
      lualine_y = { "progress" },
      lualine_z = { "location" },
    },
  },
}

11) Keybinding help

which-key.nvim pops up a cheatsheet when you press <Space>. It’s minimal and perfect for discoverability. Add custom top-level hints in lua/plugins/keys.lua:

return {
  "folke/which-key.nvim",
  opts = function()
    local wk = require("which-key")
    wk.add({
      { "<leader>f", group = "Find (Telescope)" },
      { "<leader>g", group = "Git" },
      { "<leader>l", group = "LSP" },
      { "<leader>t", group = "Test" },
      { "<leader>d", group = "Debug" },
      { "<leader>a", group = "AI" },
    })
  end,
}

12) LSP servers via Mason (one command per language)

lua/plugins/lsp.lua

return {
  "neovim/nvim-lspconfig",
  dependencies = { "williamboman/mason.nvim", "williamboman/mason-lspconfig.nvim" },
  config = function()
    local lspconfig = require("lspconfig")
    local capabilities = require("cmp_nvim_lsp").default_capabilities()

    require("mason").setup()
    require("mason-lspconfig").setup({
      ensure_installed = {
        -- Rust handled by rustaceanvim (below), but mason can still manage tools
        "pyright",                   -- Python
        "tsserver",                  -- TypeScript/JavaScript
        "bashls",                    -- Bash
        "jsonls", "yamlls", "lua_ls"
      },
      automatic_installation = true,
    })

    -- Python
    lspconfig.pyright.setup({ capabilities = capabilities })
    -- TypeScript / JS
    lspconfig.tsserver.setup({ capabilities = capabilities })
    -- Bash
    lspconfig.bashls.setup({ capabilities = capabilities })
    -- Others
    lspconfig.jsonls.setup({ capabilities = capabilities })
    lspconfig.yamlls.setup({ capabilities = capabilities })
    lspconfig.lua_ls.setup({
      capabilities = capabilities,
      settings = { Lua = { diagnostics = { globals = { "vim" } } } },
    })

    -- LSP keymaps (global)
    local map = vim.keymap.set
    map("n","gd",vim.lsp.buf.definition,{desc="LSP: goto definition"})
    map("n","gr",vim.lsp.buf.references,{desc="LSP: references"})
    map("n","K",vim.lsp.buf.hover,{desc="LSP: hover"})
    map("n","<leader>lr",vim.lsp.buf.rename,{desc="LSP: rename"})
    map("n","<leader>la",vim.lsp.buf.code_action,{desc="LSP: code action"})
    map("n","<leader>lf",function() vim.lsp.buf.format({async=true}) end,{desc="LSP: format"})
  end,
}

13) Rust superpowers (rust-analyzer, inlay hints, code actions)

Use rustaceanvim—it auto-wires rust-analyzer with Neovim’s LSP and integrates tools; don’t double-configure rust_analyzer in lspconfig. (GitHub)

lua/plugins/rust.lua

return {
  "mrcjkb/rustaceanvim",
  lazy = false, -- filetype plugin; loads on Rust buffers automatically
  init = function()
    -- Optional rust-analyzer settings
    vim.g.rustaceanvim = {
      server = {
        on_attach = function(_, bufnr)
          local map = function(m, l, r, d) vim.keymap.set(m, l, r, { buffer = bufnr, desc = d }) end
          map("n", "<leader>lc", function() vim.cmd.RustLsp("codeAction") end, "Rust: code action")
          map("n", "<leader>lh", function() vim.cmd.RustLsp("hover actions") end, "Rust: hover actions")
        end,
        settings = {
          ["rust-analyzer"] = {
            cargo = { allFeatures = true },
            checkOnSave = { command = "clippy" },
          },
        },
      },
    }
  end,
}

14) Debugging (nvim-dap + CodeLLDB)

We’ll use nvim-dap with codelldb. The wiki shows canonical config examples and options. (GitHub)

lua/plugins/dap.lua

return {
  { "mfussenegger/nvim-dap" },
  { "rcarriga/nvim-dap-ui", dependencies = { "mfussenegger/nvim-dap" } },
  { "jay-babu/mason-nvim-dap.nvim",
    dependencies = { "williamboman/mason.nvim", "mfussenegger/nvim-dap" },
    opts = { ensure_installed = { "codelldb", "python" }, automatic_installation = true },
    config = function(_, opts)
      require("mason-nvim-dap").setup(opts)
      local dap, dapui = require("dap"), require("dapui")
      dapui.setup()
      dap.listeners.after.event_initialized["dapui_config"] = function() dapui.open() end
      dap.listeners.before.event_terminated["dapui_config"] = function() dapui.close() end
      dap.listeners.before.event_exited["dapui_config"] = function() dapui.close() end
    end
  },
}

Usage:

  • Place breakpoints with F9 (map it if you want); start with :DapContinue.

  • For Rust, debug compiled binaries with codelldb. The dap wiki has a codelldb recipe. (GitHub)

15) Testing (neotest)

Use neotest framework + language adapters. It relies on Treesitter and works across Rust/Python/TS. (GitHub)

lua/plugins/test.lua

return {
  { "nvim-neotest/neotest" },
  { "rouge8/neotest-rust" },       -- Rust (cargo/nextest)
  { "nvim-neotest/neotest-python" },
  { "nvim-neotest/neotest-jest" }, -- or neotest-vitest for TS
  config = function()
    require("neotest").setup({
      adapters = {
        require("neotest-rust")({ args = { "--no-capture" } }), -- example args; customize
        require("neotest-python")({ runner = "pytest" }),
        require("neotest-jest")({ jestCommand = "npm test --" }),
      },
    })
    local map = vim.keymap.set
    map("n","<leader>tt", function() require("neotest").run.run() end, {desc="Test: nearest"})
    map("n","<leader>tf", function() require("neotest").run.run(vim.fn.expand("%")) end, {desc="Test: file"})
    map("n","<leader>ts", function() require("neotest").summary.toggle() end, {desc="Test: summary"})
    map("n","<leader>to", function() require("neotest").output.open({ enter = true }) end, {desc="Test: output"})
  end,
}

  • neotest-rust uses cargo nextest adapter; install with cargo install cargo-nextest if you want nextest. (GitHub)

16) Formatting and linting

Use built-ins where possible:

  • Rust: rustfmt & clippy (already installed via rustup).

  • Python: black (formatter), ruff (linter).

  • TS/JS: prettier (or prettierd), eslint.

  • Bash: shfmt, shellcheck.

A tiny on-save formatter:

lua/plugins/format.lua

return {
  "stevearc/conform.nvim",
  opts = {
    formatters_by_ft = {
      rust = { "rustfmt" },
      python = { "black" },
      javascript = { "prettier" },
      typescript = { "prettier" },
      typescriptreact = { "prettier" },
      json = { "prettier" },
      yaml = { "prettier" },
      bash = { "shfmt" },
      lua = { "stylua" },
    },
    format_on_save = { timeout_ms = 2000, lsp_fallback = true },
  },
}

Install tools:

# Python
pip3 install --user black ruff
# TypeScript/JS
sudo npm i -g prettier eslint typescript typescript-language-server
# Lua (optional)
sudo dnf install -y stylua
# Bash tools installed earlier (shellcheck, shfmt)

17) Diagnostics drawer

Optional but great: Trouble shows a tidy panel for LSP diagnostics, references, and more.

  • Toggle with :Trouble diagnostics

  • Lazy config already added; see core.lua.

18) Built-in spell and quick toggles

  • Spellcheck is on by default in init.lua.

  • Toggle quickly:

vim.keymap.set("n","<leader>us", function() vim.o.spell = not vim.o.spell end, { desc="UI: toggle spell" })

19) AI integration (OpenAI & local/free)

Two solid routes:

  1. OpenAI/ChatGPT inside Neovim: gp.nvim is powerful and minimal-deps. Set OPENAI_API_KEY and go. (GitHub)

  2. Local model with Ollama: avante.nvim can be wired to local providers; community docs show Ollama setups. Results vary by model; still evolving. (GitHub)

lua/plugins/ai.lua

return {
  -- Option A: OpenAI via gp.nvim (great with a ChatGPT sub using API)
  {
    "Robitx/gp.nvim",
    cmd = { "GpChatNew", "GpAppend", "GpRewrite", "GpWhisper" },
    config = function()
      require("gp").setup({
        providers = {
          openai = { -- also supports Azure, Anthropic, Ollama, etc.
            endpoint = "https://api.openai.com/v1/chat/completions",
            secret = os.getenv("OPENAI_API_KEY"),
            model = "gpt-4o-mini", -- pick your paid model
          },
        },
      })
      vim.keymap.set("v","<leader>aa", ":GpAppend<CR>", { desc = "AI: append selection" })
      vim.keymap.set("v","<leader>ar", ":GpRewrite<CR>", { desc = "AI: rewrite selection" })
      vim.keymap.set("n","<leader>ac", ":GpChatNew<CR>", { desc = "AI: new chat" })
    end,
  },

  -- Option B: local models with Ollama (Avante)
  {
    "yetone/avante.nvim",
    enabled = false, -- flip to true if you want this path
    config = function()
      require("avante").setup({
        provider = "openai_compatible", -- point to your local endpoint (e.g., Ollama via an OpenAI shim)
        openai_compatible = { endpoint = "http://localhost:11434/v1", model = "qwen2.5-coder" },
      })
    end,
  },
}

Notes:

  • gp.nvim supports multiple providers, including local (Ollama) paths. (GitHub)

  • avante.nvim is fast-moving; check its README/wiki for provider wiring details. (GitHub)

20) Bash, Python, TypeScript/CDK specifics

  • Bash: bash-language-server + shellcheck + shfmt already configured via mason and conform.

  • Python: pyright + black + ruff, debug with DAP (python adapter is ensured by mason-nvim-dap config).

  • TypeScript/CDK: tsserver via typescript-language-server, format with Prettier, test via neotest-jest or neotest-vitest.

Mason installs/updates LSP servers easily from within Neovim:

:Mason

21) Minimal workflow cheatsheet

  • Find files / grep: <Space> f f → :Telescope find_files, <Space> f g → :Telescope live_grep

  • Git hunks: ]h / [h, stage/reset hunk <Space> h s / <Space> h r, blame <Space> h b

  • LSP: gd, gr, K, <Space> l r (rename), <Space> l a (code action), <Space> l f (format)

  • Diagnostics: :Trouble diagnostics

  • Debug: :DapContinue, :DapToggleBreakpoint, UI auto-opens

  • Tests: <Space> t t (nearest), <Space> t f (file), <Space> t s (summary)

  • AI: visual select → <Space> a a (append) / <Space> a r (rewrite); chat <Space> a c

  • Terminal: :ToggleTerm (run cargo test, pytest, npm test quickly)

22) Post-install: first launch and health

nvim

Inside Neovim:

:checkhealth
:Lazy
:Mason

  • Use :Lazy to ensure plugins are installed/updated (lazy.nvim docs). (lazy.folke.io)

  • For Rust, open a Rust project file—rustaceanvim auto-activates rust-analyzer; no extra LSP config needed. (GitHub)

  • For DAP, ensure codelldb is installed via :Mason → DAP tab; use the nvim-dap codelldb wiki snippet if you want more control. (GitHub)

  • For neotest adapters, see their READMEs for advanced options (e.g., cargo nextest flags). (GitHub)

23) Troubleshooting

  • Fedora Neovim version: sudo dnf info neovim. If you need the very latest (0.10+), you can build from source (Fedora Magazine article shows steps). (Fedora Magazine)

  • Rust debug troubles: verify codelldb path and see the nvim-dap codelldb wiki. Also consider examples discussed in issues/discussions. (GitHub)

  • AI plugins: gp.nvim requires only curl by default; set OPENAI_API_KEY. For local, follow avante.nvim provider notes and community guides; model quality and “apply edits” UX can vary by model. (GitHub)

24) Why this stack?

  • Vanilla-first: Built-in LSP + Treesitter. No over-the-top distributions or heavy keymap rewrites.

  • Lazy but powerful: lazy.nvim gives simple, declarative plugin specs. (GitHub)

  • Rust-centric: rustaceanvim is the modern Rust plugin; “don’t double-configure rust_analyzer.” (GitHub)

  • Serious tooling: nvim-dap + codelldb for debugging; neotest for unified test UX. (GitHub)

Done

Comments

Post a Comment

Popular posts from this blog

Is Docker Still Relevant in 2025? A Practical Guide to Modern Containerization

-
  Docker took the IT world by storm when it was first released in 2013, introducing a simple yet powerful way to create, deploy, and manage containerized applications. Fast forward to 2025, and the containerization landscape has grown exponentially, with tools like Kubernetes, Podman, and Buildah gaining traction. So, is Docker still relevant? Let’s dive in. Docker's Core Strengths Docker remains one of the most user-friendly and widely adopted containerization tools. Its key features include: Ease of Use : Docker’s CLI and Docker Compose make it simple for developers to build and run containerized applications. Rich Ecosystem : Docker Hub is still the go-to repository for prebuilt images. Cross-Platform Support : Seamless operation across various platforms ensures it remains a top choice for development. For small to medium-sized projects, Docker’s simplicity makes it invaluable. It's a great choice for development environments, prototyping, and quick deployments. The Competit...
Read more

Going In With Rust: The Interview Prep Guide for the Brave (or the Mad)

-
 Why Rust? (No, Seriously, Why?)      Choosing Rust as your language for a coding interview is, at best, bold — and at worst, borderline reckless. Rust is not known for being ergonomic under time pressure. Unlike Python or Java, it doesn’t hold your hand when you’re fumbling through edge cases and messy input. The compiler is famously strict, and while that’s great for production code, it can feel like an enemy in a 45-minute interview. Forget about “just trying something” — Rust will make you justify every move. Want to mutate a value inside a loop? Better understand borrowing rules. Need a linked list? Be ready to bring in Rc , RefCell , and a prayer. Want to pass a slice around without cloning everything? Ownership will make you earn it. Many LeetCode problems assume a fast, flexible language — Rust is neither of those, out of the box. There’s no REPL. You can’t “just print stuff” — not without fighting the borrow checker and formatting macros. Even simple operati...
Read more

How to Set Up and Run a Minecraft Server with Forge and Mods on OCI Free Tier

-
  How to Set Up and Run a Minecraft Server with Forge and Mods on OCI Free Tier Oracle Cloud Infrastructure (OCI) offers a generous always-free tier, making it a fantastic option to host a modded Minecraft server. This guide will walk you step-by-step through setting up a Minecraft server with Forge and mods, even if you’re a complete beginner. Step 1: Sign Up for Oracle Cloud Free Tier Visit Oracle Cloud’s Free Tier page . Click on "Start for Free" and create an account. You’ll need to provide a valid email, phone number, and credit card for verification (no charges will be made). Once your account is set up, log in to the Oracle Cloud Console. Step 2: Create a Virtual Machine Instance In the Oracle Cloud Console, go to Compute > Instances . Click on "Create Instance" . Fill in the details: Name : Enter "MinecraftServer". Image and Shape : Click "Edit" next to "Image and Shape". Image : Select Ubuntu 22.04 . Shape : Choose ...
Read more