No description
  • Lua 92.8%
  • Nix 5.9%
  • Zig 0.6%
  • Vim Script 0.5%
  • C++ 0.2%
Find a file
Repository files (latest commit first)
Filename Latest commit message Latest commit date
2026-11-21 13:18:24 -05:00
lua fix(plantuml-syntax): update upstream URL 2026-11-21 13:18:03 -05:00
nix feat(nix): add home-manager module with per-language toolchains 2026-11-18 23:58:54 -05:00
resources/images docs: add showcase images 2026-09-08 12:01:37 -05:00
syntax feat(treesitter): highlight ndjson and jsonl files 2026-11-18 10:21:48 -05:00
flake.nix feat(nix): add home-manager module with per-language toolchains 2026-11-18 23:58:54 -05:00
init.lua refactor: remove dead code, document intent 2026-11-18 22:59:40 -05:00
lazy-lock.json chore(lockfile): update 2026-11-21 13:18:24 -05:00
LICENSE chore: adds LICENSE 2025-04-21 08:26:14 -05:00
README.md fix(languages): keep lockfile pins of disabled languages 2026-11-19 00:19:25 -05:00

Neovim configuration built from toggleable language integrations: each language brings its own LSP servers, formatters, treesitter parsers, plugins and debug adapters, and a host enables only the languages it uses.

Splash screen

Debugger UI

Zig development

Language integrations

Each file in lua/languages/ is one integration, named after its basename:

  • Formats: json, yaml, toml, xml, markdown, csv, ini, gitignore, jinja
  • Languages: bash, c (C, C++, CUDA), dart, gdscript, glsl, go, java (with Kotlin and Smali highlighting), latex, lua, nix, nu, plantuml, proto, python, rust, sql, vim, web (HTML, CSS, TypeScript, Tailwind, Svelte), zig
  • Tooling: docker, jupyter (molten, jupytext, quarto), competitest

An integration is a table with optional fields, all aggregated by lua/languages/init.lua:

return {
    servers = { "zls" },                         -- vim.lsp.enable names, binaries on PATH
    parsers = { "zig" },                         -- treesitter parsers
    plugins = { { "ziglang/zig.vim", ft = "zig" } }, -- lazy.nvim specs
    none_ls = function(b) return { b.formatting.shfmt } end,
    dap = { zig = "core.debugger.servers.zig" }, -- filetype -> adapter module
    setup = function() end,                      -- vim.lsp.config overrides, filetypes
}

The enabled names are read from ~/.local/share/nvim/languages.json:

{ "languages": ["zig", "lua", "json"] }

Without that file every integration loads, and its tools are expected on PATH. Plugins of a disabled integration stay in the lazy.nvim spec with enabled = false: they are not installed and :Lazy clean removes them, but their lazy-lock.json pins survive, so hosts with different language sets can share one lockfile.

To add an integration, create lua/languages/<name>.lua and give it an entry in nix/languages.nix (an empty { } when it needs no tools). Evaluation fails until both lists match.

Nix

The flake exports a home-manager module that installs Neovim, the toolchains of the enabled integrations, and languages.json.

Add the flake as an input:

inputs.nvim-config.url = "git+https://git.yhkze.net/yuuhikaze/nvim";

Then enable the module and pick languages:

{
  imports = [ inputs.nvim-config.homeManagerModules.default ];

  programs.nvim-config = {
    enable = true;
    languages = [ "zig" "lua" "json" "toml" ];
  };
}

languages is a list of known names, so a typo fails evaluation. Definitions from several modules concatenate: a shared module can set a baseline and each host can add to it.

Further options:

  • package — Neovim package (default pkgs.neovim)
  • checkout — writable checkout of this repository, linked to ~/.config/nvim (default ~/nvim). It stays a checkout rather than a store path because lazy.nvim writes lazy-lock.json into it. Activation clones it when missing
  • repository — clone URL for that checkout

Tools that are not commands reach Neovim through fixed links under ~/.local/share/nvim/: java-bundles/{debug,test} (jdtls bundles) and debugpy (a Python with debugpy, kept off PATH so it never shadows a project interpreter).

A project devshell comes first on PATH when Neovim starts inside it, so a project pinned to another toolchain version (for example zls matching its zig) uses its own.

Version pinning: the module comes from the pinned flake input, the Lua side from the live checkout. After adding an integration, push it and update the input (nix flake update nvim-config).

Requirements

  • jupyter: molten needs pynvim and jupyter_client in Neovim's python3 provider; install them in the user's Python environment
  • dart, gdscript: the Dart/Flutter SDK and the Godot editor provide their servers
  • rust: rust-analyzer comes from the rustup toolchain

Repository layout

init.lua                    entry point
lua/core/                   options, keymaps, autocommands, LSP and DAP wiring
lua/core/debugger/servers/  debug adapters (lldb-dap, debugpy, jdtls, Godot)
lua/languages/              language integrations
lua/plugins/init.lua        core plugin specs
lua/plugins/config/         plugin setups
nix/module.nix              home-manager module
nix/languages.nix           toolchain per integration