_{::lua::lazy.nvim::}

{
  "tadaa/vimade",
  opts = {
    recipe = {"default", {animate = true}},
    fadelevel = 0.4,
  }
}

_{::vimscript::vim-plug::}

Plug 'TaDaa/vimade'

For Vim & Neovim < 0.8

_::python::

function! SetupMyVimadeConfig()
python << EOF
from vimade import vimade
vimade.setup(
  recipe = ['default', {'animate':False}],
  fadelevel = 0.4,
 )
EOF
endfunction
# SetupMyVimadeConfig will be called lazily after python becomes available.
# You can call vimade.setup(...) whenever you want.
au! User Vimade#PythonReady call SetupMyVimadeConfig()

Vimade treats the setup() command as an overlay. Each time you call it, it will override any previous settings. Therefore, if you want to combine multiple settings, you must include them all in the same setup() call. If you want to reset the overlay to defaults, just call setup({}) with no options.

Correct:

require('vimade').setup({
  recipe = {'minimalist', {animate = true}},
  fadelevel = 0.3,
})

Incorrect:

require('vimade').setup({recipe = {'minimalist', {animate = true}}})
require('vimade').setup({fadelevel = 0.3}) -- This will override the recipe setting!

Vimade can fade inactive windows in a few different ways. You can control this behavior with the ncmode option.

• 'buffers': (Default) Fades all windows that do not share the same buffer as the active window. This is useful if you have the same buffer open in multiple splits and you want them all to remain highlighted.
• 'windows': Fades all inactive windows. This is a good choice if you want a clear distinction between the window you are currently working in and all other windows.
• 'focus': (Neovim 0.10+) Only fades when the :VimadeFocus command is active. This is useful for on-demand highlighting.

Most users should try each option to see what they like best.

_::lua::

require('vimade').setup{ncmode = 'buffers'} -- or 'windows' or 'focus'

_{::vimscript::}

let g:vimade.ncmode = 'buffers' " or 'windows' or 'focus'

_::python::

from vimade import vimade
vimade.setup(ncmode='buffers') # or 'windows' or 'focus'

When using a transparent terminal, your Normal highlight group has a background of NONE. Vimade needs to know the actual background color to properly calculate faded colors. For the best results, you should set the basebg option.

1. Place your transparent terminal over a pure white background (#FFFFFF).
2. Use a color picker to determine the hex code of the background color of your terminal.
3. Set basebg to this value in your configuration. You may need to darken it slightly to get the best results.

_::lua::

require('vimade').setup{basebg = '#2d2d2d'} -- or {45, 45, 45}

_{::vimscript::}

let g:vimade.basebg = '#2d2d2d' " or [45, 45, 45]

_::python::

from vimade import vimade
vimade.setup(basebg='#2d2d2d') # or [45, 45, 45]

If you are having issues with Vimade in tmux, here are a few things to try:

• 256 Colors: Vimade requires a 256 color terminal. By default, tmux may set t_Co to 8. It is recommended that you set export TERM=xterm-256color before starting Vim. You can also set set termguicolors inside Vim if your terminal supports it for an even more accurate level of fading.
• Focus Events: If you want windows to fade when switching between tmux panes, you need to enable focus events.
  1. Enable focus fading in Vimade: let g:vimade.enablefocusfading = 1
  2. Add set -g focus-events on to your tmux.conf.
  3. For Vim users, you may also need to install the tmux-plugins/vim-tmux-focus-events plugin.

You can configure Vimade to only fade windows when a floating window is open. This is useful if you only want to dim the background when you are focused on a floating window, like a popup or a dialog.

This can be achieved with a blocklist function that checks if the current window is a floating window.

Lua:

require('vimade').setup({
  blocklist = {
    demo_tutorial = function (win, current)
      -- current can be nil
      if (win.win_config.relative == '') and (current and current.win_config.relative ~= '') then
        return false
      end
      return true
    end
  }
})

Python:

Similar behaviors can be managed for python as well. Vim doesn't support Focusable floating windows, so the logic required is a bit more complex, but still achievable

from vimade import vimade
from vimade.state import globals
g_tick_id = -1
g_popup_visible = False
g_popup_winids = []
def refresh_popup_visible():
  global g_popup_visible
  global g_popup_winids
  g_popup_winids = vim.eval('popup_list()')
  any_visible = False
  for winid in g_popup_winids:
    if vim.eval(f'popup_getpos({winid})["visible"]') == '1':
      any_visible = True
      break
  if any_visible != g_popup_visible:
    g_popup_visible = any_visible
    if g_popup_visible:
      # A popup is visible, so fade the background including active win
      vim.command('VimadeFadeActive')
    else:
      # No popups are visible, so clear the fade including active win
      vim.command('VimadeUnfadeActive')
def only_behind_float_windows (win, current):
  global g_tick_id
  # This is a performance optimization. We only run the expensive
  # refresh_popup_state() function once per "tick" (screen refresh),
  # not for every single window being checked.
  if g_tick_id != globals.tick_id:
    g_tick_id = globals.tick_id
    refresh_popup_visible()
  return not g_popup_visible or win.winid in g_popup_winids

vimade.setup(blocklist = {
  'demo_tutorial': only_behind_float_windows,
})

Now, Vimade will only fade windows when a floating window is active.

The standard Vimade experience.

require("vimade").setup({recipe = {"default", {animate = true}}})

Hides low-value inactive highlights like line numbers and the end-of-buffer marker.

  require("vimade").setup({recipe = {"minimalist", {animate = true}}})

A balanced approach between window and buffer fading.

require("vimade").setup({recipe = {"duo", {animate = true}}})

Inverts the colors of the active window for a high-contrast look. (Neovim only)

require("vimade").setup({recipe = {"paradox", {animate = true}}})

Gradually fades windows based on their distance from the active window.

require("vimade").setup({recipe = {"ripple", {animate = true}}})

Recipes are the heart of Vimade's customization. A recipe is simply a collection of styles that are applied to inactive windows. You can mix and match styles to create your own unique look and feel. All of Vimade's built-in recipes are just a collection of the styles listed below, with varying degrees of complexity.

To create a recipe, you define a list of styles in your configuration. Each style is a Lua table with a specific set of options.

Here is an example of a simple recipe:

Lua:

require('vimade').setup({
  style = {
    -- Fade inactive windows by 60%
    require('vimade.style.fade').Fade({value = 0.4}),
    -- Tint the foreground of inactive windows with a blue color
    require('vimade.style.tint').Tint({
      value = {
        fg = {rgb = {100, 100, 255}, intensity = 0.2},
      }
    }),
  }
})

Python:

from vimade import vimade
from vimade.style.fade import Fade
from vimade.style.tint import Tint

vimade.setup(
  style = [
    # Fade inactive windows by 60%
    Fade(value = 0.4),
    # Tint the foreground of inactive windows with a blue color
    Tint(
      value = {
        'fg': {'rgb': [100, 100, 255], 'intensity': 0.2},
      }
    ),
  ]
)

If you create a style combination that you find particularly useful, you can abstract it into your own recipe. Recipes are located in the lua/vimade/recipe/ directory. If you believe your recipe would be beneficial to other users, please feel free to open a pull request to add it to Vimade!

Here is a list of the available styles and their options: