Linux Sin Humo (Publicaciones sobre vi/vim/neovim)

Cómo migrar de vim-plug a lazy.nvim

sebelk — Sun, 01 Jun 2025 22:50:42 GMT

Introducción

Ya vimos como convertir una una configuración en Vim script a Lua. Ese tipo de configuración es más flexible y reutilizaable. Ahora vamos por el paso final que es migrar de vim-plug a lazy.nvim.

¿Qué es lazy.nvim?

Es un gestor de plugins escrito en Lua que sabe sacar provecho de la arquitectura moderna de Neovim.

¿Qué ventajas y funcionalidades tiene lazy.nvim?

El gestor lazy.nvim se destaca por su rendimiento, usabilidad/UX y el modo de gestionar de plugins.

En la siguiente tabla vemos como se destaca en cuento a Rendimiento:

Funcionalidad/Ventaja	¿Qué significa?
Inicio ultra rápido	Arranca en segundos porque los módulos se precompilan y se cachean automáticamente.
Instalaciones livianas	Clona sólo lo esencial de los repos, ahorrando ancho de banda y espacio.
Plugins sin bloqueo del editor	Tareas pesadas se ejecutan en segundo plano, manteniendo Neovim fluido.
Análisis de rendimiento	Herramientas para medir tiempos de carga y optimizar tu configuración.
Carga bajo demanda (lazy-loading)	Plugins se cargan solo cuando se necesitan, reduciendo carga inicial y memoria.

📝 ¿Qué y dónde cachea lazy.nvim?

Directorio	Uso específico por `lazy.nvim`
`~/.cache/nvim/luac/`	Cache de bytecode Lua. Compila tu configuración en Lua a `.luac`, para que Neovim no tenga que interpretarla cada vez.
`~/.local/share/nvim/lazy/`	Instalación real de los plugins. Los plugins ya descargados no necesitan revalidarse ni reinstalarse.
`~/.local/state/nvim/lazy/`	Cache de estado: versiones exactas de los plugins, commits, fechas, hashes. Así `lazy.nvim` sabe si algo cambió.

¿Por qué migrar de vim-plug?

Los números duros

La tabla de arriba muestra que

Si bien ambos son repositoorios populares, vim-plug (que es un proyecto más longevo) supera a lazy.nvim en este aspecto.
Ambos proyectos están activos.
El repo lazy.nvim tiene más colaboradores.

En este aspecto salen bastante empatados.

Aspectos ventajosos desde el punto de vista técnico

Para sysadmins: Rendimiento y carga mínima: se puede configurar de manera natural los plugins que realmente necesitás en tu entorno (por ejemplo, se pueden configurar plugins para que solamente se carguen al usar ssh) y una configuración más clara: todo en Lua, más fácil de mantener con backups dotfiles/scripts.
Para desarrolladores: Carga por filetype y herramientas específicas y mayor control sobre dependencias y versiones.

Funcionalidad	vim-plug	lazy.nvim	Nota / Matiz
Gestión de plugins (install/update)	Sí	Sí	Ambos permiten instalar, actualizar y remover plugins fácilmente
Lazy loading de plugins	Sí (manual, limitado)	Sí (declarativo y avanzado)	vim-plug requiere configuración manual con `on`, `for`, `cmd`
Cache de estado (lockfiles, hashes)	Parcial (`:PlugSnapshot`)	Sí (`lazy-lock.json`)	vim-plug permite snapshot, pero no lo gestiona ni lo aplica automáticamente
Cache de bytecode Lua (.luac)	No	Sí	lazy.nvim compila módulos Lua para acelerar el arranque
Arranque optimizado	Parcial (con lazy manual)	Sí (caching + carga bajo demanda)	lazy.nvim acelera usando cache + lazy loading automático
Integración con configuración Lua	No (Vimscript-first)	Sí (nativo en Lua)	vim-plug puede usarse con hacks en Lua, pero no está diseñado para eso

Conceptos fundamentales para usar lazy

1. Comentarios

-- Esto es un comentario

2. Variables

local nombre = "Neovim"
local numero = 14

3. Tablas (como diccionarios o listas)

local opciones = {
  number = true,
  relativenumber = true
}

4. Funciones

local function saludar()
  print("Hola desde Lua")
end

5. Requiriendo otros archivos (modularización)

require("usuario.options")
require("usuario.plugins.lazy")

Ejemplo concreto de migración

Usamos como punto de partida el archivo ~/.config/nvim/plugins.vim del post anterior:

"Plugins (Plug)
call plug#begin('~/.vim/plugged')

Plug 'itchyny/lightline.vim'
Plug 'nyngwang/NeoTerm.lua'
Plug 'NLKNguyen/papercolor-theme'

call plug#end()

lua << EOF                                                       
require("neo-term").setup {
  exclude_filetypes = { "oil" }
}                          
EOF

nnoremap <F4> :NeoTermToggle<CR>
tnoremap <F4> <C-\><C-n>:NeoTermToggle<CR>
tnoremap <Esc> <C-\><C-n>:NeoTermEnterNormal<CR>

Clonar el repo

git clone https://github.com/folke/lazy.nvim.git ~/.local/share/nvim/lazy/lazy.nvim

Prepara el entorno

Creamos un directorio para la configuración de los plugins y otro para la configuración de lazy.nvim:

mkdir ~/.config/nvim/lua/lplugins  # Aquí estarán los archivos de configuración de los plugins
mkdir ~/.config/nvim/lua/config/

Configuración inicial

Partimos de este archivo:

-- Cargamos módulos

local commands = require('utils.commands')
local extracommands = require('utils.extracommands')
local keymaps = require('keymaps')
local opciones = require('opciones')

-- Mantenemos por ahora la configuración de plugins en Vim script
vim.cmd('source ~/.config/nvim/plugins.vim')

Y hacemos las siguientes modificaciones:

-- Cargamos módulos

local commands = require('utils.commands')
local extracommands = require('utils.extracommands')
local keymaps = require('keymaps')
local opciones = require('opciones')

-- Mantenemos por ahora la configuración de plugins en Vim script
-- vim.cmd('source ~/.config/nvim/plugins.vim')
-- require("config.lazy")

¿Qué hicimos? Deshabilitar vim-plug y por ahora dejar comentada la línea que llamará al archivo ~/.config/nvim/lua/config/lazy.lua.

Luego en dicho archivo pondremos lo siguiente:

-- Bootstrap lazy.nvim
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not (vim.uv or vim.loop).fs_stat(lazypath) then
  local lazyrepo = "https://github.com/folke/lazy.nvim.git"
  local out = vim.fn.system({ "git", "clone", "--filter=blob:none", "--branch=stable", lazyrepo, lazypath })
  if vim.v.shell_error ~= 0 then
    vim.api.nvim_echo({
      { "Failed to clone lazy.nvim:\n", "ErrorMsg" },
      { out, "WarningMsg" },
      { "\nPress any key to exit..." },
    }, true, {})
    vim.fn.getchar()
    os.exit(1)
  end
end
vim.opt.rtp:prepend(lazypath)

-- Make sure to setup `mapleader` and `maplocalleader` before
-- loading lazy.nvim so that mappings are correct.
-- This is also a good place to setup other settings (vim.opt)
vim.g.mapleader = " "
vim.g.maplocalleader = "\\"

-- Setup lazy.nvim
require("lazy").setup({
  spec = {
    -- import your plugins
    { import = "lplugins" },
  },
  -- Configure any other settings here. See the documentation for more details.
  -- colorscheme that will be used when installing plugins.
  install = { colorscheme = { "habamax" } },
  -- automatically check for plugin updates
  checker = { enabled = true },

Explicación

require("lazy").setup({ ... })

Es la función principal que inicia y configura los plugins en lazy.nvim.

spec =

Es el campo que indica la especificación de los plugins. Es el lugar para definir qué plugins cargar.

spec = {
  { import = "lplugins.ui" },
}

Cada { import = "..." } carga los plugins definidos en otros archivos lua.
En este caso, usamoos una configuración modular:
~/.config/nvim/lua/lplugins/ui.lua tendrá la especificación del plugin papercolor-theme.
~/.config/nvim/lua/lplugins/terminal.lua tendrá las especificaciones de los plugins lightline y Neoterm.

install = { colorscheme = { "habamax" } }

Establece un esquema de colores que se aplicará automáticamente en la interfaz del gestor de plugins.

checker =

Activa el verificador automático de actualizaciones. Cabe aclarar que esta configuración no los no los actualiza automáticamente, pero te avisa para que los actualices mediante el comando en modo ex (:Lazy update).

En la configuración de partida teníamos solamente 3 plugins, pero decidimos dividirlos en dos categorías, a medida que vamos instalando más plugins podemos crear más archivos lua para clasificarlos.

Especificaciones de plugins

Todos los archivos donde clasificás plugins deben tener la keyword return para que cada uno de ellos debe devuelva una tabla Lua con los plugins que querés que lazy.nvim cargue desde esos archivos.

La siguiente es una plantilla de archivo en la cual se especifican plugins:

return {
  {
    "autor/repositorio",  --  Reemplazá con el nombre del autor y nombre del repositorio
    -- lazy = false,         --  true para carga diferida, false para cargar al inicio
    -- priority = 1000,      --  Opcional. Útil para temas de colores
    -- event = nil,          --  Reemplazá con evento si usás lazy = true (ej: "BufReadPre")
    -- cmd = nil,            --  Reemplazá si querés cargar al ejecutar un comando
    -- dependencies = {},    --  Lista de plugins que este necesita (si aplica)
    -- config = function()
      -- Poné acá la configuración del plugin
    -- end
  }
}

Para echar un poco de 💡 a esta cuestión de los campos:

Campo	¿Obligatorio?	¿Qué hace?
`"autor/repositorio"`	Sí	Identifica el plugin (por ejemplo `"NLKNguyen/papercolor-theme"`)
`config = function()`	No, pero común	Configura el plugin al cargarlo
`lazy = true/false`	Opcional	Define si se carga de forma diferida o al inicio
`priority = número`	Opcional	Da prioridad de carga (útil para temas de colores)
`event = "InsertEnter"`	Opcional	Carga el plugin al ocurrir cierto evento
`cmd = "Comando"`	Opcional	Carga el plugin cuando se ejecuta un comando
`dependencies = {}`	Opcional	Especifica otros plugins requeridos

Vamos a los ejemplos concretos 💪

Archivo ui.lua

return {

  {
    "NLKNguyen/papercolor-theme",
    priority = 1000,  -- para que se cargue antes que otros
    lazy = false,     -- para que se cargue en el arranque
    config = function()                                                                                                                                       
      vim.cmd("colorscheme PaperColor")
    end
  }
}

Esto significa:

» Devuelvo una lista (tabla) con un solo plugin. Este plugin es NLKNguyen/papercolor-theme y quiero que se cargue al inicio, con prioridad alta, y que cuando se cargue, aplique el esquema de colores PaperColor.

Archivo terminal.lua

return {
  { -- Plugin 1: lightline.vim
    "itchyny/lightline.vim",
    config = function()
      vim.g.lightline = {
        colorscheme = 'solarized', -- <- podés cambiar por "jellybeans","OldHope", "wombat", "PaperColor", etc.
      }
    end,
  }, -- Separador de items en la lista

  { -- Plugin 2: NeoTerm.lua
    "nyngwang/NeoTerm.lua",
    config = function()
      require("neo-term").setup {
        exclude_filetypes = { "oil" }, -- evita que se use en buffers del tipo "oil"
      }

      -- Atajos de teclado:
      vim.keymap.set("n", "<F4>", ":NeoTermToggle<CR>", { silent = true })              -- F4 en modo normal: alterna el terminal
      vim.keymap.set("t", "<F4>", "<C-\\><C-n>:NeoTermToggle<CR>", { silent = true })   -- F4 en modo terminal: lo mismo
      vim.keymap.set("t", "<Esc>", "<C-\\><C-n>:NeoTermEnterNormal<CR>", { silent = true }) -- Esc en terminal: pasa a modo normal
    end
  }, -- Separador final, no es obligatorio pero conveniente
}

Este archivo configura dos plugins:

lightline.vim: para una línea de estado personalizada.
NeoTerm.lua: para trabajar con terminales flotantes o integrados, y define atajos con F4 y Esc para manejarlos fácilmente.

Habilitar lazy.nvim

Ya estamos casi listos, solamente falta quitar el comentario en el archivo ~/.config/nvim/init.lua:

require("config.lazy")

Eso es todo, la próxima vez, al entrar al editor, lazy.nvim se encargará de instalar los plugins especificados.

Es importante ejecutar el comando :checkhealth lazy el cual hará un diagnóstico de la instalación y configuración:

Sacándole provecho a lazy.nvim

Vamos a instalar el plugin which-key el cual sirve para mostrar de una manera amigable los atajos de teclado configurados.

Editamos el archivo de configuración ~/.config/nvim/lua/lplugins/ui.luasiguiendo la plantilla mencionada anteriormente:

return {

  {
    "NLKNguyen/papercolor-theme",
    priority = 1000,  -- para que se cargue antes que otros
    lazy = false,     -- para que se cargue en el arranque
    config = function()                                                                                                                                       
      vim.cmd("colorscheme PaperColor")
    end,                  
  },                      

{                         
  "folke/which-key.nvim", 
  event = "VeryLazy",     
  opts = {},              
  keys = {
    { "<leader>ff", "<cmd>edit ~/.config/nvim/init.lua<cr>", desc = "Edit init.lua" },
    { "<leader>fr", "<cmd>e #<cr>", desc = "Open recent file" },
    { "<leader>tt", "<cmd>terminal<cr>", desc = "Open terminal" },
    { "<leader>?", function() require("which-key").show({ global = false }) end, desc = "Buffer Local Keymaps" },
    { "<leader>q", "<cmd>q<cr>", desc = "Quit" },
    { "<leader>w", "<cmd>w<cr>", desc = "Save" },
    -- Grupos visibles (aunque no hacen nada por sí mismos)
    { "<leader>f", name = "+file" },
    { "<leader>t", name = "+terminal" },
  },
}

}

Este plugin sirve para que al teclar:

Espacioff Abrirá el archivo /.config/nvim/init.lua.
Espaciofr Abrirá el archivo más reciente.

... y así con cada uno de los atajos definidos, pero además veremos una ayuda en pantalla.

Vamos a verlo en acción:

1 Al presionar y ....
2 Muestra que es Yank que en el contexto de Vi/Vim/Neovim es copiar...
3 Aparecen automágicamente las teclas que pueden acompañar a este comando 💪

Y listo.... el resto es cuestión de usar la UI de Lazy, y familiarizarse con sus subcomandos en modo Ex.

Conclusión

vim-plug sigue siendo una opción robusta y popular, especialmente para usuarios de Vim clásico o entornos donde se necesita algo probado y ampliamente documentado.
Sin embargo, lazy.nvim es una solución moderna y centrada en Neovim, con alta participación comunitaria y buena agilidad en el mantenimiento. Ideal para setups nuevos o si des#eas aprovechar la asincronía y mejoras de Lua en Neovim.

Siempre que puedas

Consultá el README oficial
Buscá ejemplos en GitHub o Dotfiles de otros usuarios
Explorá el código fuente si sabés Lua

Estos tres artículos no han servidor para comenzar a usar Neovim, modernizar la configuración y utilizar un gestor de plugins nativo en Lua. wSiempre que agregues un plugin, revisa su README y especifica las dependencias manualmente si no estás seguro. Lazy puede resolver muchas automáticamente, pero declararlas te da más control y claridad.

Detrás de la fachada antigua, Neovim es un editor que adaptó su arquitectura a los nuevos tiempos.

¡Felicitaciones si llegaste hasta acá?

Fuentes y más recursos

¿Cómo convertir tu configuración de init.vim a init.lua?

sebelk — Thu, 15 May 2025 19:01:18 GMT

Requisitos

Curiosidad. Es la condición más importante para leer este post. Si la tendrás, con algo de esfuerzo sumado a algo de tiempo podrás aprender Vim, Neovim, etcº.
Conocimientos básicos o intermedios de Vim y haber leído el post anterior.
Conocimientos básicos de vim-plug.

Repaso de conceptos importantes

En el post anterior vimos como un usuario de Vim puede comenzar a Neovim. En el presente artículo haremos la transición de Vim script a Lua. Ok, booting the post 😄 ...

Recordemos que Vim usa Vim script (aka VimL) como lenguaje de scripting nativo. Es un lenguaje específico que permite personalizar y extender su funcionalidad. Existe en dos formas: el Vim script tradicional (también llamado "legacy script") y Vim9script (introducido en Vim 9.0), que ofrece mejor rendimiento y una sintaxis más moderna. Sin embargo Vim9script ni siquiera se usa de manera predeterminada en Vim 9.

Lua, en cambio, es un lenguaje de programación ligero, de alto nivel y multiparadigma, diseñado principalmente para ser incorporado en aplicaciones. Se destaca por su simplicidad, eficiencia y portabilidad. Neovim incorporó Lua como lenguaje de scripting alternativo, lo que ha ganado popularidad debido a su mejor rendimiento y facilidad de uso comparado con Vim script tradicional.

Cabe remarcar que Neovim usa una implementación de Lua llamada LuaJIT. LuaJIT es capaz de compilar código Lua a código máquina nativo durante la ejecución, lo que resulta en un rendimiento significativamente superior al intérprete estándar de Lua. LuaJIT es ampliamente reconocido por su alta velocidad, siendo en muchos casos comparable al rendimiento de lenguajes compilados como C. En el contexto de Neovim, LuaJIT permite que los scripts escritos en Lua se ejecuten con un rendimiento muy superior la de Lua estándar.

Diferencia de idiosincrasia:

Vim script: scripting lineal, global y directo. Bueno para pequeños ajustes, pero difícil de escalar.
Lua (Neovim): lenguaje estructurado, orientado a modularizar, reusar y escalar. Favorece el uso de variables locales, tablas y funciones que mejoran el mantenimiento de la configuración.

Entonces:

Neovim usa LuaJIT para ejecutar configuraciones en Lua de forma rápida.
Casi todas las instalaciones modernas de Neovim usan LuaJIT por defecto.
Esto significa que los scripts y configuraciones Lua en Neovim corren a velocidades cercanas al código nativo.

Ventaja clave: Permite que Neovim con Lua sea mucho más rápido que Vim script o incluso Vim9script en muchos casos.

3 conceptos esenciales — lo mínimo que siempre debés recordar

Concepto	Por qué es esencial
Tablas (`table`)	Todo en Lua usa tablas. Opciones (`vim.o`, `vim.opt`), autocmds, comandos, mappings y configuraciones de plugins.
Variables locales (`local`)	Permiten organizar el código, evitar errores y mejorar el rendimiento. Imprescindible para no contaminar el entorno global.
*API de Neovim (`vim.api.`)**	Es la manera oficial y flexible de interactuar con Neovim: crear comandos, autocmds, mappings y manipular el editor desde Lua.

Si entendés estos 3 conceptos, podés crear y mantener cualquier configuración básica y muchas avanzadas.

¿Qué es una tabla y qué no en la configuración de Neovim (Lua)

Tablas 🆗:

vim.g
vim.opt / vim.o
vim.tbl_keys(...)
Configuraciones de plugins
Listas/patrones

No son tablas ⚠ :

Funciones
Comandos ejecutados
Strings, números, booleanos

El podio de las tablas madres más importantes en Neovim

Estas son las tres tablas raíz (madre) más importantes del entorno Lua en Neovim:

🏅 vim

Es la tabla principal y núcleo del entorno Lua en Neovim. Contiene todo lo necesario para interactuar con el editor:

Subtablas como vim.api, vim.cmd, vim.opt, vim.g, vim.fn, etc.
Siempre disponible sin necesidad de importar.

🥈 _G

Es la tabla global del lenguaje Lua. Desde aquí podés definir funciones o variables globales accesibles desde cualquier parte de tu configuración:

_G.mi_funcion = function() ... end
También contiene vim como una de sus claves.

🥉 package (de Lua)

Maneja los módulos cargados por require. Es crucial para modularizar tu configuración:

package.loaded permite ver y recargar módulos.

Nota

Tablas como vim.api, vim.opt, vim.g son importantes, pero no son madres: viven dentro de vim. Lo mismo aplica para math, string, table, etc., que viven en _G.

→ Estas 3 (vim, _G, package) forman la base del entorno ejecutable de cualquier configuración Neovim moderna en Lua.

Subtablas más importantes

Tabla	Contiene	Ejemplo equivalente en Vim script
`vim.o`	Opciones globales	`set tabstop=4`
`vim.opt`	Opciones globales que contienen listas	`set nf+=alpha`
`vim.cmd`	Comandos que se ejecutan en modo ex	`colorscheme PaperColor`
`vim.g`	Variables Globales	`let g:loaded_perl_provider =`
`vim.keymap.set`	Asignación de atajos de teclado a una función o combinación de teclas	`vim.keymap.set('n', 'ñ', ':wq<CR`
`vim.api.nvim_create_user_command`	Creación de comandos personalizados	`command Nbuild execute 'w \| Silent nikola build`

Diccionario cruzado Vim script / Lua

Concepto	Vim script	Lua
Variable global	`let g:mi_var = 10`	`vim.g.mi_var = 10`
Variable local	(no hay una manera clara)	`local var = 10`
Lista	`let lista = [1,2,3]`	`lista = {1, 2, 3}`
Diccionario	`let dict = {'a':1}`	`dict = {a = 1}`
Función	`function! Hola() ... end`	`function hola() ... end`
Función anónima	no hay	`function() ... end`
Autocomando	`autocmd BufWrite ...`	`vim.api.nvim_create_autocmd`
Mapping	`nnoremap`	`vim.keymap.set`
Comando	`command ...`	`vim.api.nvim_create_user_command`

Comparativa de conceptos clave: Vim script vs Lua

Concepto	Vim script	Lua (Neovim)
Variables y configuración	Variables globales (`let g:var`), `set` para opciones	Tablas (`vim.g`, `vim.o`, `vim.opt`) y variables locales (`local`)
Automatización / lógica	Funciones (`function!`), comandos (`command`), autocmds	Funciones anónimas y definidas, `vim.api.*`, autocmds con `vim.api.nvim_create_autocmd`
Extensibilidad y estructura	Scripts planos, difícil modularizar	Modularización con `require`, `package.loaded`, uso de archivos Lua por secciones

Ejemplo de migración Vim script → Lua

Bueno, con la teoría suficiente, ✋✋ a la obra 😉. Supongamos que tenemos esta configuración de archivo init.vim:

set tabstop=4
set nf+=alpha

nnoremap ñ :wq<CR>

command -nargs=+ Silent execute 'silent !<args>' | redraw!
command Nbuild execute 'w | Silent nikola build'

filetype plugin on
runtime plugins.vim
colorscheme PaperColor

Es un archivo pequeño, pero que sirve de punto de partida para moverse a una configuración en Lua.

Crear el entorno para Neovim

Como vimos en el post anterior, mi recomendación es comenzar con un archivo init.vim. Una vez que ya estamos usando Neovim podemos realizar la migración init.lua. Sin embargo, tenemos que crear los directorios para que Neovim guarde su configuración. Lo único que dejaremos por ahora en Vim script es la configuración de plugins con vim-plug. Por lo tanto ejecutamos:

mkdir -p ~/.config/nvim/lua/utils
mkdir -p ~/.local/share/nvim/site/autoload
# Suponiendo que usabas un archivo para  
mv ~/.vim/autoload/plug.vim  ~/.local/share/nvim/site/autoload

El directorio ~/.config/nvim es obligatorio.
El directorio ~/.config/nvim/lua no es obligatorio, pero es muy útil para modularizar la configuración de Neovim.
Los nombres dados de los archivos y directorios dentroo de ~/.config/nvim/lua son totalmente arbitrarios.

En Neovim tendremos una estructura más modular. Si bien, podemos, tener, todo en init.lua, vamos a aprovecharnos de esta configuración que es mucho más flexible.

Archivo ~/.config/nvim/init.lua

-- Cargamos nuestros módulos

local commands = require('utils.commands')
local extracommands = require('utils.extracommands')
local keymaps = require('keymaps')
local opciones = require('opciones')


-- Mantenemos por ahora la configuración de plugins en Vim script
vim.cmd('source ~/.config/nvim/plugins.vim')

Archivo ~/.config/nvim/keymaps.lua

-- Alias
local map = vim.keymap.set                                                                         
-- maps
map('n', 'ñ', ':wq<CR>

Archivo ~/.config/nvim/lua/opciones.lua

-- Alias
local vo = vim.o
local vop = vim.opt

-- Opciones
vo.tabstop = 4
vop.nf:append('alpha')

Archivo ~/.config/nvim/lua/utils/commands.lua

-- Crea una tabla vacía para guardar funciones

local M = {}

function M.create_command(name, command_or_function, opts)
  pcall(vim.api.nvim_del_user_command, name)
  vim.api.nvim_create_user_command(name, command_or_function, opts or {})
end

-- Alias
local com = M.create_command

com('Silent', function(opts)
  vim.cmd('silent !' .. table.concat(opts.fargs, ' '))
  vim.cmd('redraw!')
end, { nargs = '+' })

com('Nbuild', function()
  vim.cmd('w')
  vim.cmd('silent nikola build')
end, {})


return M

Archivo ~/.config/nvim/lua/utils/extracommands.lua

-- Alias
local vcmd = vim.cmd

-- Extra commands
vcmd('filetype plugin on')
-- Esta configuración es innecesaria ya está en init.lua
-- vcmd('runtime plugins.vim')
vcmd('colorscheme PaperColor')

Archivo ~/.config/nvim/plugins.vim

Este es el único archivo que lo dejamos en Vim script (con código Lua embebido incluido):

"Plugins (Plug)
call plug#begin('~/.vim/plugged')

Plug 'itchyny/lightline.vim'
Plug 'nyngwang/NeoTerm.lua'
Plug 'NLKNguyen/papercolor-theme'

call plug#end()

lua << EOF                                                       
require("neo-term").setup {
  exclude_filetypes = { "oil" }
}                          
EOF

nnoremap <F4> :NeoTermToggle<CR>
tnoremap <F4> <C-\><C-n>:NeoTermToggle<CR>
tnoremap <Esc> <C-\><C-n>:NeoTermEnterNormal<CR>

Y Listo...

Explicación

¿Por qué definimos alias en los 3 archivos de módulos?

Los alias son básicamente variables. Los definimos porque este es un ejemplo de tipo "esqueleto" de configuración. Cuando comiences a agregar, más opciones, atajos de teclado y comandos personalizados, no querrás etipear tanto 😉.

¿Para qué agregamos la función create_command?

En Lua cuando usás la API de Neovim, si querés redefinir una función de un comando personalizado, tenés que borrarlo y volver definirlo, sino da error. Esto es para evitar sobreescrituras accidentales. Por eso creamos la función create_command para que cuando redefinamos un comando lo hagamos de manera explícita.

Usa pcall para borrar el comando personalizado y si no existe no da error.
Vuelve a recrearlo con la nueva definición.

¿Acaso el comando Nbuild hace lo mismo en Vim script que en Lua? Vamos a analizarlo.

1. Brevedad vs mantenibilidad

VimL:

vim command -nargs=+ Silent execute 'silent !<args>' | redraw! command Nbuild execute 'w | Silent nikola build'

Es breve, directo y funciona. Pero:

Es poco expresivo
No permite manejar errores fácilmente
No escala bien con lógica compleja
Lua:

lua com('Silent', function(opts) vim.cmd('silent !' .. table.concat(opts.fargs, ' ')) vim.cmd('redraw!') end, { nargs = '+' })

Es más verboso, sí, pero:

La función puede ser más compleja si se necesita
Es programable y reutilizable
Puede integrarse con condicionales, bucles, o lógica externa

2. Control de errores y depuración

En VimL: si un comando falla, tenés poco margen para capturar y manejar el error.
En Lua: podés usar pcall, vim.notify, vim.fn.systemlist, y construir mensajes personalizados o fallback si algo sale mal.

local ok, _ = pcall(function()
  vim.cmd('silent !nikola build')
end)
if not ok then
  vim.notify('Error al ejecutar nikola build', vim.log.levels.ERROR)
end

3. Modularización

En Lua podés agrupar comandos en módulos, con require(...).
En VimL tenés que recurrir a runtime, source, y no hay namespaces claros.

local commands = require('utils.commands')
commands.create_command(...)

Esto facilita dividir la configuración en archivos lógicos, más fácil de leer, mantener y compartir.

4. Compatibilidad futura y ecosistema Neovim

Neovim ha declarado que Lua es su lenguaje de configuración nativo moderno.
La mayoría de los plugins modernos están escritos en Lua.
VimL sigue siendo soportado, pero está siendo superado funcionalmente.

5. Legibilidad a largo plazo

Aunque VimL sea más corto, en un entorno de colaboración o con configuraciones grandes, Lua:
Es más explícito.
Permite documentar.
La API de Neovim en Lua permite un uso más explícito y predecible de tipos de datos.
Es más fácil de extender con lógica externa.

Conclusión

Si sabés migrar opciones, mappings, comandos y cargar plugins → podés convertir el 80% o más de tu init.vim (equivalente el viejo .vimrc) a init.lua.

Migrar tu configuración de Neovim de Vim script a Lua no solo representa una mejora técnica inmediata, sino también una oportunidad para afilar tu pensamiento en términos de estructura, modularidad y optimización.

Lua te invita a organizar tu configuración como un sistema flexible y componible, donde cada parte puede ser reutilizada, testeada y afinada con precisión. Este tipo de enfoque —más declarativo, más explícito— entrena tu mente en formas modernas de entender y construir software.

A medida que domines la integración de herramientas, el manejo eficiente de datos y la automatización de tareas dentro de Neovim, estarás cultivando hábitos que trascienden tu editor: aprenderás a diseñar entornos complejos donde múltiples componentes cooperan de forma orquestada.

Esa forma de pensar, de buscar la mejora continua y construir sistemas cada vez más elegantes y potentes, es lo que hoy distingue a los profesionales más relevantes del ecosistema tecnológico.

Apéndice : Los 10 conceptos fundamentales de Lua (resumen)

Si querés profundizar, te propongo 7 conceptos extra para profundizar en el uso de Lua en Neovim:

Concepto	Descripción breve
Tablas (`table`)	Estructuras clave-valor o listas. Base de toda la configuración.
Variables locales (`local`)	Para mantener el código limpio y evitar contaminación global.
Funciones anónimas	Permiten definir acciones sin nombre, usadas en mappings, autocmds y comandos.
*API de Neovim (`vim.api.`)**	Puente entre Lua y Neovim: crear comandos, mappings, autocmds.
`vim.opt` vs `vim.o`	Para configurar opciones. `vim.o` para valores simples, `vim.opt` para manipular listas.
`require`	Para cargar módulos externos y dividir la configuración.
Paréntesis en llamadas	Obligatorio usar `()` al llamar funciones.
Referencias	Asignar una tabla a otra variable sin copiarla (ejemplo: `local vg = vim.g`).
`\_G (global)`	Tabla especial que contiene las variables y funciones globales accesibles en toda la configuración.
`package.loaded`	Permite ver o manipular qué módulos están cargados, útil para recargar configuraciones dinámicamente.

Fuentes y más Recursos

Una introducción pragmática al uso de plugins en Neovim

sebelk — Sun, 04 May 2025 19:22:12 GMT

Ya me he referido a Neovim alguna vez en el pasado: Lo viejo, lo bueno y lo nuevo en Neovim . Se pueden extender las funcionalidades de neovim, mediante plugins, de manera similar a las de su predecesor, el editor Vim. En este artículo propongo un modo muy sencillo y lo más transparente posible para el uso de plugins en Neovim.

Hay dos tipos de plugins:

Globales: Funcionan para todo tipo de archivos.
Filetype: Sirven para un tipo particular de archivos**.

El siguiente listado muestra plugins globales que forman parte del core de neovim:

ls -l /usr/share/nvim/runtime/plugin
total 60
-rw-r--r-- 1 root root  411 mar 26 10:48 editorconfig.lua
-rw-r--r-- 1 root root 3677 mar 26 10:48 gzip.vim
-rw-r--r-- 1 root root  904 mar 26 10:48 man.lua
-rw-r--r-- 1 root root  138 mar 26 10:48 matchit.vim
-rw-r--r-- 1 root root 7966 mar 26 10:48 matchparen.vim
-rw-r--r-- 1 root root  152 mar 26 10:48 netrwPlugin.vim
-rw-r--r-- 1 root root 2160 mar 26 10:48 osc52.lua
-rw-r--r-- 1 root root 2017 mar 26 10:48 rplugin.vim
-rw-r--r-- 1 root root 1778 mar 26 10:48 shada.vim
-rw-r--r-- 1 root root  236 mar 26 10:48 spellfile.vim
-rw-r--r-- 1 root root 2527 mar 26 10:48 tarPlugin.vim
-rw-r--r-- 1 root root  442 mar 26 10:48 tohtml.lua
-rw-r--r-- 1 root root  202 mar 26 10:48 tutor.vim
-rw-r--r-- 1 root root 2642 mar 26 10:48 zipPlugin.vim

Plugin	Funcionalidad
`editorconfig`	Busca y lee archivos .editorconfig para aplicar reglas de indentación, fines de línea y codificación
`gzip`	Editar archivos comprimidos con gzip
`man`	Abrir páginas del manual en el editor
`matchit`	Extiende la funcionalidad del comando `%`
`matchparen`	Resalta paréntesis coincidentes
`netrwPlugin`	Maneja la transferencia de archivos y listado de directorios remotos a través de una red
`osc52`	Detecta si es posible usar el código de escape ANSI para copir desde vim a otras terminales para poder copiar texto desde neovim usand el clipboard del sistema
`rplugin`	Gestiona, migra, actualiza y carga remote plugins automáticamente (están escritos en otros lenguajes como Python, Ruby, Node.js, etc y que se manejan de manera independiente del editor sin afectar el rendimiento)
`shada`	Datos Compartidos entre las sesiones de neovim
`spellfile`	Descarga de archivos de ortografía
`tarPlugin`	Exploración de tarballs
`tohtml`	Conversor a html
`tutor`	Tutorial
`zipPlugin`	Exploración de archivos zip

Los scripts en vimL pueden contener comandos de edición, estructuras de control, funciones, manejo de listas, diccionarios, y puede simular objetos mediante diccionarios con referencias a funciones. El otro lenguaje nativo que incorpora neovim es Lua. Los desarrolladores de neovim consideran que ese lenguaje es más eficiente, tiene una sintaxis más moderna y estándar, maneja mejor los errores, permite que sea extendido fácilmente con plugins y módulos complejos, sin necesidad de depender de procesos externos o hacks.

Si consideramos el archivo del plugin man contiene lo siguiente:

if vim.g.loaded_man ~= nil then
  return
end
vim.g.loaded_man = true

vim.api.nvim_create_user_command('Man', function(params)
  local man = require('man')
  if params.bang then
    man.init_pager()
  else
    local err = man.open_page(params.count, params.smods, params.fargs)
    if err then
      vim.notify('man.lua: ' .. err, vim.log.levels.ERROR)
    end
  end
end, {
  bang = true,
  bar = true,
  range = true,
  addr = 'other',
  nargs = '*',
  complete = function(...)
    return require('man').man_complete(...)
  end,
})

local augroup = vim.api.nvim_create_augroup('nvim.man', {})

vim.api.nvim_create_autocmd('BufReadCmd', {
  group = augroup,
  pattern = 'man://*',
  nested = true,
  callback = function(params)
    local err = require('man').read_page(assert(params.match:match('man://(.*)')))
    if err then
      vim.notify('man.lua: ' .. err, vim.log.levels.ERROR)
    end
  end,
})

📝 Mini resumen conceptual — man.lua

✔ ¿Qué hace el plugin?

Define cómo abrir manpages usando comandos (:Man) y URIs (man://...).
Define cómo manejar errores (usa vim.notify).

✔ ¿Cómo funciona?

Previene carga múltiple con vim.g.loaded_man.
Crea un comando :Man con opciones (bang, autocompletado, etc.).
Crea un autocmd que detecta buffers con URI man:// y carga la manpage.
Usa funciones (open_page, init_pager, read_page, man_complete) definidas en el módulo man.
Muestra errores con vim.notify si algo falla.

✔ ¿Qué flujo sigue?

Usuario → :Man o :edit man:// → función del módulo man → buffer con la manpage

✅ El plugin es 100% todo Lua

Usa API moderna de Neovim:
vim.api.nvim_create_user_command
vim.api.nvim_create_autocmd
vim.notify
Usa variables globales Lua: vim.g.loaded_man
Usa funciones Lua: string.match, require, etc.

Es un plugin moderno, pensado para ser usado con Neovim o Vim con soporte de Lua.

API para plugins y herramientas

Además, neovim posee una API con la cual se pueden hacer desarrollos en otros lenguajes de programación y por eso existen plugins y/o herramientas relacionadas que no están escritos en vimL o LUA:

El plugin far.vim está desarrollado en python:

Se debe ejecutar :UpdateRemotePlugins cada vez que un plugin remoto se instale, se actualice, o se borre. Esto generará o actualizará un archivo manifest, por ejemplo:

cat ~/.local/share/nvim/rplugin.vim 
" node plugins


" python3 plugins
call remote#host#RegisterPlugin('python3', '/root/.local/share/nvim/plugged/far.vim/rplugin/python3/far', [
      \ {'sync': v:false, 'name': '_far_nvim_rpc_async_invoke', 'type': 'function', 'opts': {}},
     \ ])


" ruby plugins


" python plugins

Equivalencias entre Vim y Neovim

Abro un paréntesis para recordar las equivalencias entre archivos de Vim y Neovim:

Elemento	Vim	Neovim
Config principal	`~/.vimrc`	`~/.config/nvim/init.vim` o `init.lua`
Carpeta de configuración	`~/.vim/`	`~/.config/nvim/`
Plugins (autoload)	`~/.vim/autoload/`	`~/.local/share/nvim/site/autoload/`
Plugins (paquetes)	`~/.vim/pack/`	`~/.local/share/nvim/site/pack/`
Datos de usuario (swap, undo, backup, etc.)	Dentro de `~/.vim/` o definido por el usuario	`~/.local/state/nvim/`
Swap files	`~/.vim/swapfiles/`	`~/.local/state/nvim/swap/`
Undo files	`~/.vim/undodir/`	`~/.local/state/nvim/undo/`
Backup files	`~/.vim/backup/`	`~/.local/state/nvim/backup/`
viminfo	`~/.viminfo`	No se usa directamente
shada	No aplica (usa viminfo)	`~/.local/share/nvim/shada/main.shada`
Colorschemes	`~/.vim/colors/`	`~/.config/nvim/colors/`
After directory (sobreescribir plugins/config)	`~/.vim/after/`	`~/.config/nvim/after/`

Nota sobre shada:

Vim usa viminfo → ~/.viminfo.
Neovim usa shada → ~/.local/share/nvim/shada/main.shada.

No es recomendable hacer enlace simbólico entre estos dos archivos porque no son 100% compatibles.

Soporte nativo para plugins en Vim 8 (y en adelante)

Photo by Handy Wicaksono on Unsplash

Desde Vim 8.0 el editor cuenta con soporte nativo para paquetes. En Vim un paquete no es otra cosa que un directorio de plugins. Es decir, considerando el siguiente escenario.

El paquete lightline.vim se va a cargar automáticamente al abrir el editor, mientras que el otro plugin toggleterm podrá activarse con el comando :packadd toggleterm.nvim

Guía rápida para el método nativo de Vim 8+

Mostraré como usar 2 plugins.

1. Crear las carpetas necesarias

Abrí tu terminal y ejecutá:

mkdir -p ~/.vim/pack/misplugins/{start,opt}

Explicación rápida:

~/.vim/pack/ → carpeta donde Vim busca paquetes.
misplugins → nombre del grupo que quieras (puede ser cualquier nombre).
start/ → indica que los plugins se cargan automáticamente al abrir Vim.
opt/ → indica que los plugins se cargarán bajo demanda con el comando packadd

2. Descargar los plugins

Ahora dentro de start/, cloná los repositorios de Git de los plugins:

cd ~/.vim/pack/misplugins/opt

# vim-fugitive (permite ejecutar y gestionar comandos de Git directamente dentro de Vim, como hacer commits, ver logs, ver diferencias (diffs) y manejar ramas sin salir del editor.)
git clone https://tpope.io/vim/fugitive.git
vim -u NONE -c "helptags fugitive/doc" -c q

cd ~/.vim/pack/misplugins/start

# lightline.vim (barra de estado mejorada)
git clone https://github.com/itchyny/lightline.vim.git
# Usar el comando siguiente si lightline.vim se muestre sin colores y guardarlo en algún archivo de configuración del shell.
# export TERM=xterm-256color

Con esto ya los tenés instalados.

3. Configuración para lightline.vim|

Podés agregar algunas líneas en tu ~/.vimrc para aprovechar lightline.vim:

" Opcional: configuración mínima para lightline
set laststatus=2

4. Listo

¡Abrí Vim y ya podés usar el plugin lightline.vim!

Si querés cargar el plugin fugitive, lo hacés con:

:packadd fugitive

Importante: Los plugins escritos en lua no funcionarán en Vim

Algo interesante en Vim y Neovim es que podemos ver los plugins que ya vienen con el editor con el comando :help standard-plugin-list y con :help local-additions los plugins que vamos agregando:

O si preferimos algo más sofisticado, para ver nuestros plugins:

:echo join(keys(g:plugs), ' ')

Si bien esta funcionalidad también existe en Neovim, podemos administrar los plugins de manera más flexible y automatizada. Esto nos lleva a considerar el uso de gestores de plugins.

Gestores de plugins

Existen varios gestores de plugins:

Me parece muy recomendable vim-plug porque:

Requiere muy poca configuración: una lista con los paquetes de plugins deseados.
Instala y actualiza todos los paquetes de nuestra lista o los que seleccionemos.
Detecta y elimina plugins que borramos de nuestra lista.
Muestra el estado de los plugins.
Genera instantáneas de nuestros paquetes con su configuración, con la posibilidad de restaurarlas.
Posee atajos de teclado.
Es compatible tanto con Vim como Neovim

Si queremos deshabilitar todos los plugins podemos ejecutar nvim --noplugin.

Neovim sigue los lineamientos de la XDG Base Directory Specification. Algo que puede ser muy útil: poner el listado de plugins en un archivo separado. Esto es: creando un archivo ${XDG_CONFIG_HOME:-$HOME/.config}/nvim/plugins.vim y en el archivo ${XDG_CONFIG_HOME:-$HOME/.config}/nvim/init.vim teniendo una simple línea:

runtime plugins.vim

Entonces, comentando esa línea es una manera alternativa para desactivarlos.

Pero hay más: supongamos que tenemos esta configuración en el archivo ${XDG_CONFIG_HOME:-$HOME/.config}/nvim/plugins.vim:

Plug 'nyngwang/NeoTerm.lua'

call plug#end()

" Esta es la manera de embeber código lua en un archivo de tipo vimL
lua << EOF
require("neo-term").setup {
  exclude_filetypes = { "oil" }
}
EOF

nnoremap <F4> :NeoTermToggle<CR>
tnoremap <F4> <C-\><C-n>:NeoTermToggle<CR>
tnoremap <Esc> <C-\><C-n>:NeoTermEnterNormal<CR>

Con esta configuración:

Al presionar F4 se abirá una terminal.
Al presionar de vuelta F4 se cerrará la terminal.
Con Esc se vuelve al modo Normal en la terminal.

En tiempos en los que tanto se declama la agilidad, como contrasentido se ofrecen editores que consumen muchos recursos, con desarrollos no exentos de torpezas y caprichos impuestos de antemano. El minimalismo de Vim como de Neovim nos permite adaptarlo de acuerdo a lo que necesitemos, la posibilidad de agregar distintas funcionalidades, sea para desarrollo, mejor usabilidad y experiencia del usuario (sí: el desarrollador o sysadmin también es un usuario 😀). Finalmente, si bien tanto Vim como Neovim poseen el soporte nativo para manejar paquetes de plugins, encuentro en vim-plugin una manera mucho más conveniente de hacerlo.

Característica	Sistema Nativo (Vim 8 `packages`)	`vim-plug`
Instalación	Manual (clonar repos en `pack/`)	Automática vía script (`plug.vim`)
Configuración	En `vimrc`, usando `packadd` o estructura `start/opt`	Declarativa en `vimrc` con `Plug`
Carga diferida (lazy-loading)	Manual con `packadd` desde `opt/`	Incorporado: `on`, `for`, `cmd`, `event`
Instalación de plugins	Manual (`git clone`)	`:PlugInstall`
Actualización	Manual (`git pull` en cada plugin)	`:PlugUpdate`
Desinstalación	Manual (borrar carpeta)	`:PlugClean`
Gestión de dependencias	No soportado nativamente	Limitada (tú defines el orden)
Soporte para branches/tags	Manual (`git checkout`)	Sí (`Plug 'user/repo', { 'branch': 'dev' }`)
Paralelismo en instalación	No	Sí (instala varios plugins a la vez)
Interfaz de usuario	Ninguna	Básica pero útil (durante instalación/update)
Velocidad en carga	Muy rápida (carga solo en startup)	Muy rápida con lazy loading
Soporte oficial	Parte de Vim 8+	Mantenido por la comunidad
Curva de aprendizaje	Mayor (entender estructura `pack/`)	Muy simple y bien documentado
Compatibilidad	Solo Vim 8+	Compatible con Vim 7.4+, Neovim

Conclusión

El soporte nativo de Vim/Neovim es como una biblioteca física organizada con dos tipos de estantes:

start/: son los libros que se abren automáticamente apenas entrás a la biblioteca —es decir, los plugins que se cargan al iniciar Vim/Neovim.
opt/: son libros que están en los estantes, pero que vos tenés que buscar y abrir manualmente usando el comando :packadd.

Este sistema te da control total, pero también requiere que te ocupes de la instalación, organización y carga de cada plugin.

Los gestores de plugins, como vim-plug, funcionan como un sistema de préstamo digital moderno:

Suscripción básica: Declarás qué libros (plugins) querés en una lista de solicitudes (Plug 'autor/plugin'), y al ejecutar un comando como PlugInstall, el sistema los descarga automáticamente y los organiza en las secciones correspondientes del runtimepath.
Dependencias = citas bibliográficas que debés declarar manualmente: Si el libro A necesita al libro B para entenderse correctamente, vos tenés que pedir ambos explícitamente. A diferencia de gestores como npm, pip o cargo, no hay resolución automática de dependencias: nadie deduce relaciones por vos.
Actualizaciones periódicas: Usando el comando PlugUpdate, podés sincronizar tu colección con las últimas ediciones disponibles. Eso sí: estos comandos actualizan lo que ya tenés, pero no agregan automáticamente nuevos plugins a menos que los declares en tu configuración.

Ahora cabe preguntarse dos cosas:

¿Cómo podemos empezar a usar Lua?
Más allá de que vim-plug es una excelente opción: ¿Es actualmente la mejor para Neovim?

Más Recursos

Cómo pegar texto en VIM usando Ctrl-v

sebelk — Wed, 25 Dec 2019 23:03:22 GMT

Cuando copiamos un texto desde otro programa y lo queremos pegar en VIM, no podemos usar el atajo de teclado Ctrl-v. Sin embargo, podemos usar la siguiente configuración para poder hacerlo

imap <C-v> <C-o>"+p

Dicha configuración hay que guardarlo en el archivo ~/vimrc (en el caso de neovim usar ~/.config/nvim/init.vim).

¡Eso es todo!

VIM + Markdown = Sorprendente

sebelk — Sat, 08 Dec 2018 20:24:44 GMT

¿Qué es?

En artículos anteriores ya habíamos hablado acerca de Markdown. VNote es una aplicación para tomar notas, diseñado especialmente para Markdown. Pero no es otro editor más. No posee doble panel como ReText o Haroopad. Tampoco es WYSIWYG como Typora o Mark Text. El problema con el primer enfoque es que contar con dos paneles no favorece a la concentración. La segunda táctica contradice en cierta manera el espíritu de markdown que es la capacidad de tener control sobre lo que se está escribiendo.

El intento de VNote por acortar la distancia entre escritura y lectura que ofrece Markdown es muy ingenioso. Recuerda al WYSIWYM del editor LyX. Claro, la diferencia es que markdown es por lejos, mucho más amigable que LaTeX.

VNote usa libretas, carpetas y notas para la jerarquía de las notas para administrar las notas. Este principio de una 1 nota, 1 archivo favorece la gestión por parte del usuario. Algo que no ocurre con otros intentos como MindForger, por citar un ejemplo.

Ficha

VNote
Author: Le Tan
Licencia: MIT
Sitio Web: tamlok.github.io/vnote

¿Para qué sirve?

Para escribir notas y organizarlas
Los siguientes usos no fueron parte principal del propósito que tuvo en mente el desarrollador, no obstante, se puede adaptar bastante bien para:*
- Para escribir artículos técnicos
- Para escribir posts para un blog
- Para escribir documentación

Funcionalidades

Facilita el ingreso de textos frecuente (Snippets)
Expansión de palabras permite el ingreso de la fecha actual, nombres y otros textos de manera rápida (Word Magic). Viene con una lista predeterminada, pero se pueden agregar más a la misma
Plantillas
Temas y estilos
Guarda sesiones, es decir permite seguir trabajando con los mismos archivos que teníamos abierto en la sesión anterior
Exportación: Markdown con sus imágenes y adjuntos en una carpeta para distribuir, motor interno para convertir a pdf. También soporta la conversión usando wkhtmltopdf u otro comando personalizado.
Potente motor de búsqueda, que permite buscar entre una o más notas e incluso por tags de las mismas.
MathJax para interpretar ecuaciones matemáticas $$ a^2 + b^2 = c^2 $$
Diagramas mediante Mermaid o Flowchart

graph TD
A(VNote)-->B[Qué es];
     A-->C[Para qué se usa];
     A-->D[Funcionalidades];
     A-->E[Como instalarlo];
     A-->F(Conclusión);

Soporte para emojis

**Por favor no vote a un :cat: **

Pestañas
Modo vim

Conclusiones

Me gusta que tenga un modo lectura y un modo edición, en lugar de código puro y panel para previsualizar, el modo Vim es sorprendente y para mis preferencias y necesidades lo convierte en un claro ganador frente a otras alternativas. Asimismo, la impresión que genera VNote es la de un proyecto que se ha interesado en detalles que a veces se pasan por alto en proyectos Open Source.

¿Buscando Más?

Lo viejo, lo bueno y lo nuevo en Neovim

sebelk — Mon, 20 Nov 2017 16:25:51 GMT

Características

El editor Neovim se presenta como el sucesor del editor Vim.

El conector entre componentes de software, MessagePack de manera eficiente intercambia datos en binario y sirve para intercambiarlos en lenguajes tales como JSON.
Los plugins remotos son coprocesos que tienen un canal de comunicación por medio de RPC con el proceso de neovim. Estos plugins además se ejecutan de manera asíncrona, mejorando así el rendimiento.
Una configuración predeterminada más potente y amigable.

La configuración predeterminada incluye las siguientes funcionalidades:

Cuando se detecta que un archivo ha sido cambiado dentro de Vim, automáticamente lo lee de vuelta.
Permite borrar una autoindentación, saltos de línea y al comienzo de inserción.
Ahora los directorios de backup están en ~/.local/share/nvim/backup siguiendo las directrices xdg [^{^1}]
Resalta los resultados coincidentes de búsquedas
Realiza búsquedas incrementales
Muestra siempre la línea de estado
Ahora se pueden ver mejor las tabulaciones y espacios al final de cada línea
Muestr el comando que se está ejecutando
Manejo más inteligente de tabulaciones
Asume una terminal de conexión rápida
La campanilla está deshabilitada para todos los eventos
El directorio para temporales está en ~/.local/share/nvim/swap [^{^1}].
El comando display muestra la última línea de los registros.
Justifica automáticamente usando el ancho del texto, inserción y borrado inteligente de caracteres de comentarios.

Configuración

En $HOME creamos un enlace:

lrwxrwxrwx 1 sergio sergio 19 nov 5 23:30 init.vim -> /home/sergio/.vimrc

Y también en $HOME/.config:

lrwxrwxrwx 1 sergio sergio 17 nov 5 23:30 nvim -> /home/sergio/.vim

En $HOME/.vimrc

if has(‘nvim’) 
  Plug ‘Shougo/deoplete.nvim’, { ‘do’: ‘:UpdateRemotePlugins’ } 
  Plug ‘vim-airline/vim-airline’ 
else 
  Plug ‘Shougo/deoplete.nvim’ 
  Plug ‘roxma/nvim-yarp’ 
  Plug ‘roxma/vim-hug-neovim-rpc’ 
  python3 from powerline.vim import setup as powerline_setup 
  python3 powerline_setup() 
  python3 del powerline_setup 
  set laststatus=2 
  set t_Co=256 
endif 
 
let g:deoplete#enable_at_startup = 1 
 
neoterm 
Plug ‘kassio/neoterm’ 
 
“call vundle#end()            “ required 
call plug#end()

Nuevas funcionalidades provenientes de plugins

Algunos de estos plugins son:

far.vim: Buscar y remplazar, abre un panel de vista previa.
deoplete.nvim: Autocompletar.
floobits: Etherpad usando neovim.
neoterm: Terminal embebida.
vim-pandoc: Integración con el conversor de lenguajes de marcas ligeros pandoc.

Conclusión

El editor VIM es una extraordinaria herramienta, no obstante adolece de disparidad en sus configuraciones predeterminadas, algunos inconvenientes de rendimiento e integración con otros componentes de software. Neovim viene a responder a estos inconvenientes y por ahora lo está haciendo muy bien. De hecho, VIM en su versión 8, incorporó muchas mejoras provenientes de Neovim. El tiempo dirá si los proyectos se terminan fusionando. Lo importante es que tenemos una alternativa moderna al casi treintañero VIM.

Notas

[ _^1 ]: Freedesktop.org

5 ejemplos: Usar la shell sin salir de vim

sebelk — Sun, 24 Sep 2017 12:38:45 GMT

A veces estamos trabajando con un archivo y queremos ejecutar una serie de comandos, pero sin salir del editor. Veremos varias maneras de hacerlo.

1. El comando Ex shell (sh)

Este comando ((sh)ell)) sirve para abrir una shell sin cerrar el editor.

Importante: Para volver de la shell al editor se puede usar el atajo de teclado o Ctrl-d o bien el comando exit

2. Edición de archivos de la shell

Aquí estamos editando el archivo .bashrc, para que se apliquen los cambios podemos ir a la shell en modo login con:

:set shell=bash\ –login

3. Guardar e ir a la shell

En este ejemplo vemos como se puede aplicar los cambios en un servicio

:w | sh

Aquí la clave es el carácter “|” el cual sirve para ejecutar el comando (sh)ell luego de w.

4. Ejecución de bajo perfil

El comando silent ejecuta el comando de manera silenciosa y el comando redraw! limpia y actualiza la pantalla.

5. Ejecutar el archivo en edición

Al escribir un script en lugar de guardar, salir, ejecutar el script y volver a editarlo, podemos ejecutarlo directamente desde vim:

La clave en cuestión aquí es el carácter ‘%‘ que indica el buffer de la ventana actual.

10 cosas extraordinarias que podés hacer con VIM

sebelk — Sun, 10 Apr 2016 08:52:29 GMT

Últimamente este editor ha comenzado a tener mala prensa. Se dice que es difícil, anticuado.
En este artículo intentaremos mostrar 10 características distintivas de vim. Muchos creen que VIM es parte de un caprichoso rito de iniciación al mundo UNIX/Linux. Usar VIM no es un hábito snob de algunos geeks, sino una manera de aumentar la productividad.
La cuestión es que algunas distribuciones incluyen de manera predeterminada vi en lugar de VIM. El usuario principiante entonces, al tropeza con aquél, huye hacia otros editores en apariencia más fáciles pero mucho menos potentes. Aquí mostraremos 10 funcionalidades que posee VIM que difícilmente otro editor de texto puede ofrecer, al menos todas juntas.

Cabe aclarar que el siguiente listado es para usaurios que poseen un conocimiento básico de VIM. ¿Todavías no lo tenés? ¡Usá la herramienta vimtutor!

0. Concentrarte en el texto

Muchos editores poseen una gran cantidad de botones y de menús, pero eso muchas veces quita espacio en la pantalla, además de distraernos. VIM está libre de esas intereferencias.
Incluso, tiene plugins y configuraciones para acentuar estas características.¹²

¿Queremos leer y/o editar archivos de texto o tener que aprendernos para que sirve cada botoncito u opción de cada menú? ¿Qué sentido tiene?

1. Comprobar la ortografía

El comando en modo ex:

:setlocal spell spelllang=es_MX

Establece el idioma que utilizará ViM para la corrección ortográfica. El corrector resaltará las palabras con errores. Al situar el cursos en la palabra mal escrita y usar el comando z= aparecerá una lista de palabras alternativas para reemplazar la incorrecta.

2. Operaciones con bloques

Es común al editar archivos con código fuente encontrarnos con porciones de texto encerrados entre algunos de estos caracteres:

<Esto es un Ejemplo>
“Esto es un Ejemplo”
‘Esto es un ejemplo’
(Esto es un ejemplo)
[Esto es un ejemplo]
{Esto es un ejemplo}

Para seleccionar el texto encerrado entre signos “<” y “>” podemos usar el siguiente comando:

vi<

Si quisieramos seleccionar el texto incluyendo los signos deberíamos usar:

va<

En castellano una regla mnemotécnica útil es:

i: interior
a: afuera (inclusive)

Para seleccionar cualquiera de los otros bloques, sencillamente hay que reemplazar el caracter delimitador del bloque.

Esto es muy útil para archivos html, en la siguiente imagen se muestra como se puede seleccionar todo un tag mediante el comando vat:

Por supuesto en lugar del comando inicial v se pueden usar otros tales d, y y c.

3. Viajar en el tiempo (controlar ediciones… casi como si fuera GIT)

Este una funcionalidad que ya presenté en un un artículo anterior, pero que tiene sentido mencionar una vez más:

Con Vim se puede volver al estado que tenía el archivo 10 minutos atrás con el comando en el comando en modo ex:

:earlier 10m

Por supuesto, se puede volver al futuro con:

:later 10m

¿Qué pasa si no se pone ‘m’? En eseo caso se retrocede o avanza la cantidad de ediciones especificada.

4. Automatización de operaciones

Hay una manera muy sencilla de repetir operaciones: y es a través del comando .
Dicho comando repite el último comando y repetirlo la cantidad que sea necesaria, sencillamente usando el “punto” las veces que sea necesario. Cuando el comando a repetir es muy complejo es una función de extrema utilidad.

Otra manera de repetir operaciones es anteponiendo un número de veces. Por ejemplo, el comando 10p pega 10 veces el contenido del buffer.

También se pueden usar macros para automatizar tareas utilizando macros:

Prendemos la grabadora con qa
Ejecutamos los comandos deseados
Detenemos la grabadora con q
Reproducimos el comando con @a

Por ejemplo podríamos usarlo para estructurar un documento en markdown de la siguiente manera:

:set nf+=alpha (Para habilitar el incremento de caracteres alfabéticos)
Tipeamos ## A. (sin las comillas)
qa
yyp
Usamos el atajo de teclado Ctrl-a (Para incrementar)
q
Utilizamos 10@a (el número 10 es un ejemplo)

5. Abrir dos archivos al mismo tiempo

Esta función es extremadamente útil. Hay varias maneras de hacerlo, aquí mostraré una manera de hacerlo.

Por ejemplo, si tenemos un archivo y queremos copiar el contenido de otro archivo, debemos ejecutar este comando en modo ex:

:split /etc/squid3/squid.CONF

Desde luego la ruta del archivo es un ejemplo. Luego podemos copiar, cortar, pegar entre las diferentes como es habitual. Lo más importante es saber como pasar entre ventanas: primero se emplea el atajo de comandos Ctrl-w y luego la tecla de la flecha en dirección a la ventana deseada.

Si esto parece complicado, se puede usar incluso el modo ex:

:wincmd j

6. Editar un archivo web al vuelo

Supongamos que estamos copiando código libre de un sitio web a un archivo, podríamos usar el comando siguiente:

vim http://www.fsf.org/index.html

Luego de presionar Enter se descarga el archivo html y se abre una copia en el editor. ¿No es maravilloso?

7. Editar un archivo remoto a través de ssh

Este método es múy útil en particular cuando se utilizan claves públicas para autenticar. Hay que hacer así:

vim scp://root@192.168.80.148//etc/squid3/squid.conf

A diferencia del ejemplo anterior este comando edita efectivamente el archivo remoto. Obviamente usa un archivo local de manera temporaria hasta que guardamos los cambios…

8. Explorar archivos

Aquí mediante el comando

:e .

Se abre un explorador de archivos que permite por ejemplo copiar archivos de un directorio a otro.
El procedimiento es tal vez contraintuitivo, pero no por eso es complejo.

Se navega como es habitual en gestor de archivos hasta encontrar el directorio de destino. Ubicado allí el cursos se usa el comando mt.

Luego buscamos el archivo que queremos copiar y usamos los comandos mf y mc.

¡Listo! Se copió el archivo al directorio de destino.

9. Autocompletar texto

Si tenemos que volver a tipear una palabra larga podemos hacerlo rápida y fácilmente con el atajo de teclado Ctrl-p.

En el ejemplo siguiente queremos ingresar rápidamente la función isunordered:

VIM tiene además, otras maneras de completar téxto fácilmente mediante el atajo de teclado Ctrl-x. Por ejemplo ingresando luego el atajo de teclado Ctrl-f, podremos escribir rutas de archivos velozmente:

Cabe aclarar que todos estos atajos se usan en modo Insert.

¡Qué lo disfruten!

Cosas sorprendentes con ViM

sebelk — Mon, 27 Sep 2010 06:54:18 GMT

Sorpresa 1

Abrir directamente un archivo en un determinado número de linea, por ejemplo: línea 247:

vim +247 /ruta/al/archivo

Sorpresa 2

Ejecutar un comando en modo Ex al abrir un archivo:

vim +:set nu /ruta/al/archivo

Sorpresa 3

Con Vim se puede volver al estado que tenía el archivo 10 minutos atrás con el comando en el comando en modo ex:
:earlier 10m

Por supuesto, se puede volver al futuro con:

:later 10m

¿Qué pasa si no se pone ‘m’? En eseo caso se retrocede o avanza la cantidad de ediciones especificada.

Sorpresa 4

Convertir un archivo en html en modo ex se hace así:

:TOhtml

El resultado se puede ver aquí es un ejemplo de un archivo Makefile.in convertido a HTML.

Sorpresa 5

Editar un archivo de manera remota:

vim ftp://remotehostname.com/myfile