u/NazgulResebo

In this video, I customize the Neovim statusline from scratch without using any plugins.

We start with the statusline option and learn how to add different items to it, use colors and highlight groups, and create functions to provide dynamic information.

Then I show how to display the current mode, use external tools to provide information, and add useful Git and LSP information to the statusline.

Topics covered:

• The statusline option
• Adding items to the statusline
• Colors and highlight groups
• Functions in the statusline
• Showing the current mode
• Using external tools
• Git information
• LSP information

Everything is built using Neovim's built-in functionality, without relying on a statusline plugin.

Video: https://youtu.be/7nslXbSH12E

Source Code: https://github.com/FractalCodeRicardo/dev-config/blob/master/nvim/lua/my/status-line-example.lua

In this video, I explore the new shader system in Kitty 0.49 and show how to create and customize shaders.

We'll cover:

1. Pipeline and Slang shader files
2. Customizing an existing Kitty shader
3. Using pipeline files Combining multiple shaders with a pipeline
4. Creating a basic shader from scratch with Slang
5. Creating a Mandelbrot shader

Kitty 0.49 now supports custom shaders that can add visual effects to your terminal.

In this video, I go through 18 shaders and show effects such as CRT, bloom, cursor trails, fireworks, northern lights, ripples, and more.

01 - bloom — Adds a soft glow around bright terminal content.

02 - crt-blue — CRT-style display effect with a blue tint.

03 - crt — Simulates an old CRT monitor with curved/distorted screen effects.

04 - cursor-trail-blaze — Makes the cursor leave a fiery trail as it moves.

05 - cursor-trail-lightning — Makes the cursor leave an electrical/lightning trail.

06 - dim-inactive-windows — Dims inactive windows so the active window stands out.

07 - fireworks-rockets — Animated fireworks with rockets launching upward.

08 - fireworks — Animated fireworks exploding in the terminal background.

09 - focus-highlight — Briefly highlights a window when it receives focus.

10 - inside-the-matrix — Animated green Matrix-style digital effect.

11 - negative — Inverts the terminal's colors.

12 - northern-lights — Animated Aurora Borealis-style lights.

13 - pond-ripple — Creates a water ripple effect around mouse clicks.

14 - spot-light — Follows the mouse with a spotlight effect.

15 - tab-change — Briefly highlights the active window when changing tabs.

16 - tft — Simulates the visual characteristics of a TFT display.

17 - underwater — Gives the terminal an underwater/wavy appearance.

18 - water — Creates an animated water-like effect.

Neovim 0.13 introduces vim.log, a new API for creating and managing logs from Lua.

In this video, we explore the new logging API and see how to use it in your Neovim plugins and configurations.

Topics covered:

• The new :log command
• The new methods in vim.log API
• vim.log.new() and creating loggers
• The new vim.Log class
• vim.log.levels
• Getting and setting the log level
• Customizing log output with set_format_func()

In this video, I take a look at the new text objects:

1. al (all lines)
2. il (inner line)

I show how they work with common operators like:

1. d — delete
2. c — change
3. y — yank
4. v — select

I also compare these new text objects with how you had to perform the same operations in older versions of Neovim.

Neovim 0.13 introduces vim.async, a new API designed to make asynchronous Lua code cleaner and easier to manage.

In this video, I talk about why this API was introduced, the problems it solves, and the basics so you can start to use it.

In this video

1. Why vim.async was introduced (callback-hell and event loop)
2. Using the run method and understandng async context
3. Understanding tasks and how to control them
4. Execution of top tasks and child tasks
5. Using checkpoints with await, checkpoint, and pawait
6. Converting callback-based functions into regular functions with await and wrap
7. Practical and illustrative examples

By the end of the video, you'll have the basic understanding to write robust, cleaner and manageable async code.

Neovim 0.13 brings an subtle improvement to the autoread option that makes working with AI agents much smoother.

In previous versions, autoread could detect external file changes only when the buffer gained focus. In Neovim 0.13, it uses a file watcher to detect changes immediately, so your buffer can update as soon as an AI agent modifies the file.

In this video, I compare the behavior between Neovim 0.12 and Neovim 0.13 and show why this is especially useful when working with AI coding agents.

In this video, I take a complete look at the new multicursor functionality in Neovim 0.13, starting with the basics and moving into more advanced topics.

I'll explain how multiple cursors work, compare them with traditional macros, and provide examples.

In the first part of the video, I cover:

• Multicursor basics — Learn how to create and use multiple cursors.
• Multicursors vs. macros — See how multicursors differ from macros.

Then I provide these examples:

• Create a list from words
• Create a Markdown checklist
• Capitalize text with multicursors
• Csv file to json
• Use multicursors with regex
• Use multicursors with grep and quickfix
• Combine multicursors with macros

Hope you like it!

In my previous video, many of you asked me for markdown images using vim.ui.img, so here is a complete example.

I cover how to:

• Detect images under the cursor
• Handle cursor movement with autocommands
• Preview local images using relative and absolute paths
• Preview images hosted on the web
• Make HTTP requests to download remote images
• Parse Markdown image syntax
• Display images directly inside Neovim using `vim.ui.img`

Source code:
https://github.com/FractalCodeRicardo/dev-config/tree/master/nvim/lua/my/markdown-images

local api = vim.api
local fn = vim.fn
local img = vim.ui.img
local net = vim.net

local function parse_image(line)
  local l = vim.trim(line)
  local is_image = l:sub(1, 2) == "!["

  if not is_image then
    return nil
  end

  local image = vim.split(l, "%(")[2]
  image = image:sub(1, #image - 1)
  return image
end

local function is_web(file)
  return file:sub(1, 4) == "http"
end

local function get_blob(file, callback)
  if not is_web(file) then
    callback(fn.readblob(file))
    return
  end

  net.request(
    file,
    {},
    function(err, res)
      callback(res.body)
    end
  )
end

api.nvim_create_autocmd("CursorMoved", {
  callback = function()
    local win = api.nvim_get_current_win()
    if not api.nvim_win_is_valid(win) then
      return
    end

    local line = api.nvim_get_current_line()
    local file = parse_image(line)

    if file == nil then
      return
    end

    if not is_web(file) and fn.filereadable(file) ~= 1 then
      return
    end

    get_blob(file, function(content)
      vim.schedule(function()
        img.set(content, {
          col = 55,
          row = 1,
          width = 35,
          height = 15
        })
      end)
    end)
  end
})

Neovim 0.13 introduces vim.ui.img, a new API that makes working with images directly from Neovim much easier.

In this video, I take a look at the new vim.ui.img API and explore how it works. We'll go through the main functions, including get, set, and del, and then use them to build practical examples.

You'll see how to:

• Get, create, and delete images with vim.ui.img
• Move images programmatically
• Resize images dynamically
• Create a simple live image preview inside

Source Code:

https://github.com/FractalCodeRicardo/dev-config/tree/master/nvim/lua/my/vim-img

A few weeks ago, I made a video about dimmed dark themes. Many of you were asking for light themes, so I made this video for you.

There is a discussion about whether light themes are better for your eyes or not. Personally, I find them very comfortable in the morning, and I like using them from time to time. However, when my eyes are already tired, I prefer using something like dark Gruvbox or Kanagawa.

My favorites in this showcase are:

Kanagawa
Rose Pine
Bamboo

I hope you enjoy it!

Neovim 0.13 is getting a new built-in directory viewer: dir.lua.

In this video, I take a look at this new file browser, compare it with the existing netrw and plugins like Oil, and show how to use and customize it.

dir.lua is still a relatively simple directory viewer, but it's lightweight, fast, and surprisingly customizable. I'll show you how to:

- Open and navigate directories

- Toggle the directory viewer

- Refresh the file list

- Add custom icons with decorators

- Hide dotfiles

- Change the file sorting order

- Add a live file preview

- Customize the viewer using Neovim's Lua API

Here is the source code of the customizations:

https://github.com/FractalCodeRicardo/dev-config/tree/master/nvim/lua/my/dir-lua-customizations

The Neovim API has improved a lot, and you can build surprisingly useful things with it in just a few minutes. In this video, I built a live preview for Oil.nvim.

I'm very impressed by the cool things we can build with only 30 lines of code.

Source code:
https://github.com/FractalCodeRicardo/dev-config/blob/master/nvim/lua/my/oil-live-preview.lua

local api = vim.api
local buf = api.nvim_create_buf(false, true)
local win = api.nvim_open_win(buf, true, {
  relative = "editor",
  col = 50, row = 0,
  width = 35, height = 20,
  border = "rounded",
  style = "minimal"
})

vim.bo[buf].filetype = "lua"

api.nvim_create_autocmd("CursorMoved", {
  callback = function()
    local c_win = api.nvim_get_current_win()

    if not api.nvim_win_is_valid(c_win) then
      return
    end

    local c_buf = api.nvim_win_get_buf(c_win)
    local cursor = api.nvim_win_get_cursor(c_win)

    local line = api.nvim_buf_get_lines(c_buf, cursor[1] - 1, cursor[1], false)[1]
    local file = vim.split(line, " ")[4]

    if vim.fn.filereadable(file) == 1 then
      local content = vim.fn.readfile(file)
      api.nvim_buf_set_lines(buf, 0, -1, false, content)
    end
  end
})

In this video I explain all you need to know to start using the spell checker:

1. How to enable it

2. How to fix a misspelling

3. How to move forward and backward misspellings

4. How to add new words in the dictionary

5. How to remove words from the dictionary

I thought Neovim’s built-in themes were pretty bad, but after trying them, maybe I won't use plugins anymore 😅.

Here is my top 5:

1. Catppuccin
2. Zaibatzu
3. Retrobox
4. Sorbet
5. Darkblue

Which one is your favorite?

In this video, I explain a method I use to learn Vim/Neovim and focus only on what I need, avoiding information overload.

The method consists of 4 steps:

1. Identify a problem
2. Identify solutions to that problem
3. Keep the solution that covers the most cases
4. Learn the rest later

Search and replace in a single file is easy in Neovim, but replacing text across an entire project or workspace can be trickier, or require the help of a plugin.

In this video, I review 5 different methods for search and replace across multiple files:

1. Using MagicDuck/grug-far.nvim
2. Using nvim-pack/nvim-spectre
3. Using :args and :argdo
4. Using the quickfix list and :cdo
5. Creating a custom command with ripgrep and :grep

Just wanted to have some fun I tried to do some animations using cellular-automaton.nvim

1. Slide: Move the buffer characters from left to right (this one is given by the plugin creator)
2. Random Swap: Randomly swap the characters.
3. Bouncing: Make the characters behave like bouncing balls.
4. Rotation: Rotate the characters around the center of the screen.
5. Explosion: Move the characters away from the center.
6. Particles: Turn every character into a particle with its own direction.
7. Ants: Make every character behave like an ant that changes direction on every frame.

Source code:
https://github.com/FractalCodeRicardo/dev-config/blob/master/nvim/lua/my/cellular-automaton.lua

Hope you like it!,

If you have done some animations, share them here please!

Lately, I've been getting a bit tired of the overproductivity culture that's everywhere on social media, so I put together a list of plugins to waste time with absolutely no particular purpose.

1 Play Doom - seandewar/actually-doom.nvim
2 Donut - NStefan002/donut.nvim
3 Snake - Febri-i/snake.nvim
4 Cellular Automaton - eandrju/cellular-automaton.nvim
5 Tetris - alec-gibson/nvim-tetris 
6 KillSheep - seandewar/killersheep.nvim
7 NyanCat - koron/nyancat-vim 
8 VimBeBetter (Vim be good) - szymonwilczek/vim-be-better
9 Christmas three - rhysd/vim-syntax-christmas-tree 
10 Pets - MeF0504/vim-pets
11 Sudoku - jim-fx/sudoku.nvim

Marks are really easy to learn and use. Maybe you don't need Harpoon or a similar plugin. In this video, I explain just three commands to get started using them, and maybe you won't need to learn anything more.

1. m + an uppercase letter → set a mark at your cursor position

2. :marks → see all your current marks

3. ' (single quote) + the letter → jump straight back to that spot