# Srcery for Vim: a 16 colour dark scheme with eight switches to adjust

> srcery-vim is a Vim Script colour scheme for Vim and Neovim built on the 16 colour base palette of a terminal, with a dark background and configurable text styles. It installs with any of the usual plugin managers, and the project ships a matching terminal scheme in a separate repository.

**srcery-colors/srcery-vim** —  An occult color scheme for (n)vim. Perform your dark magick using clearly defined contrasting colors with a pinch of earthly tint for that lived-in feel. 

- Repository: https://github.com/srcery-colors/srcery-vim
- Website: https://srcery.sh
- Stars: 906 · Forks: 61
- Language: Vim Script
- License: NOASSERTION
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/srcery-colors-srcery-vim

## Built on the 16 colour base of a terminal, not on a fresh palette

Srcery is a colour scheme for Vim and Neovim, and the design decision that defines it is stated in the introduction: the colours were created so that they logically adhere to the 16 colour base palette of a given terminal while retaining their own identity. That is a narrower and more interesting constraint than inventing a palette from scratch.

The stated goal is legibility over long sessions in an editor or terminal emulator, using clearly defined contrasting colours with what the project calls a pinch of earthly tint. The palette itself lives in the same family as the dark background values, and the three colour variables the README lists as examples are a near-black, a red and a green, with a separate background variable.

Who this is for is easy to define. People who have already tuned their terminal colours and want their editor to look like part of the same setup, rather than a separate application pasted into a shell. It also matters that the scheme is aimed at both Vim and Neovim, and the repository reflects that: the top level holds colors/, autoload/, lua/, doc/ and cliff.toml, so the colour definitions and a Lua entry point live side by side with the Vim Script ones.

The trade-off of tying yourself to a 16 colour base is that fidelity drops where a terminal cannot do more. The README states that most modern terminals support 24 bit colour and that srcery works best with that, with 8 bit colour supported as a fallback. The fallback exists, but the README does not say which highlights lose precision in it, which is the first thing to check if your terminal is old.

## Cloning into a packages directory and calling packadd

The installation path that the README documents for Vim 8 relies on the native packages mechanism, so a git clone into the right directory is all the setup there is. Clone the repository into your themes package directory:

```bash
git clone https://github.com/srcery-colors/srcery-vim ~/.vim/pack/themes/opt/srcery-vim
```

The clone has to land in a path ending in pack/themes/opt, because that is where Vim looks for package contents, and the directory name has to match the package name you are about to add. Then your .vimrc needs two lines, one to put the package on the runtime path and one to select the scheme:

```vim
packadd! srcery-vim
colorscheme srcery
```

The same approach works for Neovim, but the clone target differs because Neovim looks in its own configuration directory:

```bash
git clone https://github.com/srcery-colors/srcery-vim $XDG_CONFIG_HOME/nvim/pack/themes/opt
```

Note that the second clone does not name a subdirectory, so the repository lands directly inside the opt folder, and the package name stays srcery-vim. That is the detail to get right, because a mismatch between the directory name and the packadd! argument is the usual reason a scheme silently does not load.

There is also a manual route for anyone who does not want a clone at all. The README says you can use colors/srcery.vim however you want, and it also warns that some plugin themes need the entire project cloned and placed on your runtimepath. If you only want the colours, one file is enough. If you want the associated plugin themes, take the whole repository.

## Seven plugin managers, one line each

Because the scheme is a plugin, every popular plugin manager has its own one line spelling. dein.vim uses a call form:

```vim
call dein#add('srcery-colors/srcery-vim')
```

vim-plug uses the Plug form:

```vim
Plug 'srcery-colors/srcery-vim'
```

vim-pathogen expects the repository to be cloned into your bundle directory:

```bash
cd ~/.vim/bundle
git clone https://github.com/srcery-colors/srcery-vim
```

packer.nvim uses a Lua table with an alias, which is the one that also gives the scheme a different name to invoke:

```lua
use {'srcery-colors/srcery-vim', as = 'srcery'}
```

lazy.nvim takes a spec table with an explicit priority and lazy loading turned off, so the theme is applied at startup rather than on demand:

```lua
{
    "srcery-colors/srcery-vim",
    lazy = false,
    priority = 1000,
}
```

And vim.pack, the Neovim built-in package manager, takes a source URL:

```lua
vim.pack.add({
  { src = 'https://github.com/srcery-colors/srcery-vim' },
})
```

The order of those lines matters in one place. The lazy.nvim spec with priority 1000 and lazy = false is how a theme gets loaded early enough to be applied at startup, and the README says the same thing in prose terms: set the variables before assigning colorscheme. A theme that loads after the colorscheme command has already run will not take effect until you reload it, which is the most common first-run complaint with schemes like this one.

## Eight switches that must be set before the scheme loads

Srcery exposes a short list of configuration variables, and the README is explicit that they have to be set before assigning the colorscheme, because the scheme reads them once as it loads.

The list is short enough to take in at a glance. There are five style toggles that are all enabled by default: g:srcery_bold, g:srcery_italic, g:srcery_underline, g:srcery_undercurl and g:srcery_strikethrough. Then there is g:srcery_inverse, also on by default, which applies inverse highlighting for visual selection and search. g:srcery_guisp_fallback defaults to 'NONE', and when set to 'fg' or 'bg' it switches to an alternate highlight for terminals that cannot show a coloured underline or undercurl. Finally g:srcery_normal_float defaults to 0, and setting it to 1 makes floating windows use the Srcery colours for their background and border.

In a vimrc that looks like this:

```vim
let g:srcery_normal_float = 1
```

And in a Neovim init.lua the same variable is set through the vim.g table:

```lua
vim.g.srcery_normal_float = 1
```

The guisp_fallback option is the interesting one for anyone on an older terminal, since undercurl is exactly the kind of feature terminals tend to lack. The inverse option is the one most likely to be turned off, because inverse highlighting for search and visual selection is a strong visual effect and a matter of taste. The float option matters for anyone using a Neovim popup or floating window, since a plugin window drawn with a default background will otherwise clash with the scheme.

## Every colour is a variable you can overwrite

The palette is not fixed. The README explains that each of Srcery's colours can be customised, and gives the red colour as the example. In a vimrc:

```vim
let g:srcery_red = '#FF0000'
```

In a Neovim init.lua:

```lua
vim.g.srcery_red = '#FF0000'
```

The variables follow a naming pattern built on the base colour names, g:srcery_black for the default background value, g:srcery_red, g:srcery_green and so on. The README also documents a separate g:srcery_background variable that you can set instead of g:srcery_black, which matters because the background is the one colour most people want to change and the one most likely to be set to something other than the palette default.

There is a documented escape hatch for the background in particular. Setting that variable to 'NONE' makes the background inside Vim transparent, which lets the terminal's own background show through instead of the scheme's. That is a small line of configuration with a large visual effect, and it is the piece that lets the theme coexist with a terminal background you already chose.

The colour list in the README is presented as an expandable table of variables with default values and swatches, so the full set of names is discoverable in the documentation rather than having to be guessed from the source. The badge in the README header points at a separate published package, @srcery-colors/srcery-palette, which appears to be where the palette values are maintained outside the editor plugin.

## A matching terminal scheme, and a licence that needs reading

The one thing the README explicitly offers beyond the editor scheme is a paired terminal. It points to a repository of terminal configurations from the same organisation, srcery-terminal, for people who want the terminal colour scheme to match Vim. That is a real difference in approach from editor themes that define their own full RGB palette: the palette stays anchored to a terminal's 16 colour base, so the terminal and the editor can agree without hunting for a matching terminal theme by eye.

The second thing to read before adopting anything is the licence. The licence field on the repository says Other, a custom licence that GitHub cannot classify, and a LICENSE file sits at the top of the tree. The README also carries a copyright line for the project. Because the terms are custom rather than a standard permissive grant, the safe approach is to open the LICENSE file and read the terms yourself before shipping the scheme in a dotfiles repository you publish, or in a product you distribute. This review cannot interpret what the file permits.

On maintenance, the repository is not archived and the last push was on 2026-10-03, with the default branch named master. The tagged releases are v3.0.0 from 2026-05-07, v2.1.0 from 2025-08-27 and v2.0.0 from 2023-11-16. A major version jump from 2.x to 3.0.0 with no intermediate tag suggests the output may have changed between them, so if you have stored a colour scheme reference or scripted against the old names, that is the thing to check.

## Conclusion

Srcery is worth adopting if your terminal already speaks 24 bit colour and you want a dark, high contrast editor theme that follows the 16 colour base of your terminal rather than inventing a new palette, and the eight g:srcery_* options make it easy to turn off the bold and italic clutter. It is the wrong choice if your terminal is limited to 8 bit colour and you need exact hex fidelity, since the scheme falls back and the README does not say which highlights degrade, or if you need a theme with documented support commitments, since the licence field on the repository says Other, a custom licence, and the tag list jumps from v2.1.0 to v3.0.0. Before you install, read the LICENSE file, set any g:srcery_* variables before the colorscheme command, and check that your terminal can render the undercurl and italic styles the scheme asks for.

## FAQ

### How do I install srcery-vim in Neovim?

Clone the repository into the Neovim pack directory with `git clone https://github.com/srcery-colors/srcery-vim $XDG_CONFIG_HOME/nvim/pack/themes/opt`, then add `packadd! srcery-vim` and `colorscheme srcery` to your config. The README also lists install lines for dein.vim, vim-pathogen, vim-plug, packer.nvim, lazy.nvim and vim.pack.

### Why does my srcery configuration not apply until I reload the theme?

The README states that configuration variables must be set before assigning colorscheme. The scheme reads the g:srcery_* values as it loads, so set them first and then run `:colorscheme srcery`.

### Can I make the Vim background transparent with srcery?

Yes. The README says setting g:srcery_background to 'NONE' makes the background inside Vim transparent, and that variable can be set in place of the default g:srcery_black.

### Does srcery work in a terminal with only 8 bit colour support?

It is supported as a fallback, but the README says srcery works best with 24 bit colour, which most modern terminals support. If you are limited to 8 bit, the g:srcery_guisp_fallback option lets you switch coloured underline and undercurl highlighting to an alternate form.

### What licence does srcery-vim use?

The licence field on the repository says Other, a custom licence GitHub cannot classify, and the project keeps the terms in the LICENSE file at the top of the tree. Read that file before redistributing the scheme, since this is not one of the standard permissive grants.

## Sources

- [Issues](https://github.com/srcery-colors/srcery-vim/issues)
- [Project website](https://srcery.sh)
- [README](https://github.com/srcery-colors/srcery-vim/blob/master/README.md)
- [Releases](https://github.com/srcery-colors/srcery-vim/releases)
- [srcery-colors/srcery-vim on GitHub](https://github.com/srcery-colors/srcery-vim)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/srcery-colors-srcery-vim