Rewrite README in English

1 files changed, 62 insertions, 61 deletions

diff --git a/README.md b/README.md
index 7cd10e1..2faebbe 100644
--- a/README.md
+++ b/README.md
@@ -1,55 +1,56 @@
-# Configuracion Para Neovim
+# Neovim Configuration
 
-Esta es mí configuración para Neovim, un editor de texto que uso para programar.
-La uso todos los dias, puede ser visto en mis videos de [youtube](https://youtube.com/@Alpha_Dev) y directos en [twtich](https://twitch.tv/theAlphaDeveloper)
+This is my Neovim configuration, the text editor I use for programming.
+I use it every day, and you can see it in my [YouTube](https://youtube.com/@Alpha_Dev) videos and [Twitch](https://twitch.tv/theAlphaDeveloper) streams.
 
-El objetivo de mi configuracion es ayudarme en mi trabajo cotidiano convirtiendo neovim en la mejor herramienta para poder programar.
+The goal of this configuration is to help me in my daily work by turning Neovim into the best possible tool for programming.
 
-## Instalación
+## Installation
 
 ```sh
 git clone https://git.all.ar/pub/nvim-conf.git ~/.config/nvim
 ```
 
-Repositorio: <https://git.all.ar/pub/nvim-conf>
+Repository: <https://git.all.ar/pub/nvim-conf>
 
 ## Neovim
 
-Utilizo siempre la ultima version de Neovim (actualmente 0.13), hago el build desde el source code una vez por semana (quizas aveces mas si estoy aburrido jaja).
-Voy reemplazando plugins por funcionalidad nativa de Neovim siempre que se pueda: statusline, colorscheme, LSP y treesitter ya no dependen de plugins externos para lo básico.
+I always use the latest version of Neovim (currently 0.13), building it from source about once a week (maybe more often if I'm bored, haha).
+I keep replacing plugins with native Neovim functionality whenever possible: the statusline, colorscheme, LSP and treesitter no longer depend on external plugins for the basics.
 
 ![](Neovim.png)
 
-## Opciones, Autocomandos y Keymaps
+## Options, Autocommands and Keymaps
 
-Opciones relacionadas al editor se encuentran en `./lua/config/options.lua`
-Configuraciones relacionadas a keymaps relacionadas al editor y no a plugins se encuentran en `./lua/config/keymaps.lua`
-Autocomandos que quiero registrar se encuentran en `./lua/config/autocmds.lua`
-En el mismo directorio se encuentra la configuracion para "Diagnostic" donde configuro los iconos a mostrar para los errores que pueden ser por LSP u otras herramientas, dado que neovim lo maneja como un modulo aparte me gusta tenerlo por serparado.
+Editor options live in `./lua/config/options.lua`.
+Editor keymaps (not plugin-related ones) live in `./lua/config/keymaps.lua`.
+Autocommands I want to register live in `./lua/config/autocmds.lua`.
+The same directory holds the "Diagnostic" configuration, where I set the icons shown for errors coming from LSP or other tools. Since Neovim handles diagnostics as a separate module, I like to keep it on its own.
 
-Todas estas configuraciones las cargo con el evento `VeryLazy` utilizando un autocomando.
+All of these configurations are loaded on the `VeryLazy` event through an autocommand.
 
 ## Plugins
 
-Para plugin manager utilizo [lazy](https://github.com/folke/lazy.nvim) el setup del plugin se encuentra en `./lua/config/lazy.lua`
-Utilizo la funcionalidad de lazy donde se puede especificar un directorio `./lua/plugins/` como fuente para las especificaciones de los plugins.
-Trato de configurar un plugin por archivo, llamando a este archivo como el plugin o como la funcionalidad que realiza.
-Nota tambien tengo el archivo `./lua/plugins/init.lua` donde tengo los que no separe, o no me parece suficiente logica para separarlos en su propio archivo de una linea.
+I use [lazy](https://github.com/folke/lazy.nvim) as the plugin manager; its setup is in `./lua/config/lazy.lua`.
+I use lazy's ability to take a directory, `./lua/plugins/`, as the source of plugin specs.
+I try to configure one plugin per file, naming the file after the plugin or the feature it provides.
+Note that there is also `./lua/plugins/init.lua`, which holds the plugins I haven't split out, or that don't have enough logic to deserve their own one-line file.
 
-### Configuraciones
+### Configuration
 
-Para configurar los plugins utilizo la opcion de lazy `config` donde se puede definir de las siguientes formas.
-Utilizando la opcion `opts` no es necesario utilizar el `config` dado que lazy va a ver la opcion y automaticamente hacer el `require("plugin").setup(opts)` con las opcioens definidas
-Utilizando el valor `true` para `config` donde le indica que tiene que hacer el `require("plugin").setup()` pero sin opciones.
-Utilizando una funcion como valor para `config` donde directamente configuro lo necesario ahi.
-Utilizando una funcion como valor para `config` donde llamo a otro archivo como `./lua/pi/lsp` donde la configuracion es extensa y entonces no quiero tenerla toda ahi.
+To configure plugins I use lazy's `config` option, which can be defined in the following ways:
 
-### LazyLoading
+- Using the `opts` option, `config` isn't needed: lazy sees the option and automatically calls `require("plugin").setup(opts)` with the given options.
+- Setting `config` to `true`, which tells lazy to call `require("plugin").setup()` with no options.
+- Setting `config` to a function where I configure everything directly.
+- Setting `config` to a function that calls another file, such as `./lua/pi/lsp`, when the configuration is long and I don't want it all inline.
 
-Dado que utilizamos el package manager llamado lazy no podia dejar de hablar de esto que es una de sus configuraciones mas importantes, como configurar los plugins para que se carguen solo cuando son necesarios.
-Es normal que plugins son solamente requeridos para algunos momentos, entonces no tiene sentido hacerlos cargar al inicio cuando no sabemos siquiera si van a ser ejecutados.
-Como ejemplo voy a utilizar `./lua/plugins/database.lua` que es el cual me permite realizar consultas a bases de datos desde dentro de neovim [video](https://youtu.be/su7lWYjnM44).
-Este cumple con lo antes mencionado que no quiero que se cargue cuando inicia neovim.
+### Lazy loading
+
+Since the package manager is called lazy, I can't skip one of its most important features: configuring plugins so they only load when they're needed.
+Many plugins are only needed at certain moments, so it makes no sense to load them at startup when we don't even know whether they'll be used.
+As an example, take `./lua/plugins/database.lua`, which lets me query databases from inside Neovim ([video](https://youtu.be/su7lWYjnM44)).
+It fits the case above: I don't want it loaded when Neovim starts.
 
 ```lua
 return {
@@ -66,52 +67,52 @@ return {
 }
 ```
 
-Para poder realizar eso utilizo la propiedad `keys` la cual cumple una doble funcion.
+To achieve this I use the `keys` property, which serves two purposes:
 
-- le indica a lazy que el plugin solo debe cargarse cuando se apreta esa combinacion de teclas.
-- Si tiene un segundo argumento la definicion la toma como el valor o funcion con la cual configurar el keymap, lo cual permite tener un solo lugar donde definir los keymas para el plugin y que lazy sepa cuales son.
+- It tells lazy that the plugin should only load when that key combination is pressed.
+- If it has a second element, it's used as the value or function for the keymap, so there's a single place to define the plugin's keymaps and lazy knows about them.
 
-Otra manera para hacer el lazyloading es con la opcion `cmd` la cual funciona similar a la de `keys` pero solo que recibe los comandos con los cual va a triggerear la carga del plugin y luego la ejecucion.
+Another way to lazy load is the `cmd` option, which works like `keys` but takes the commands that trigger loading the plugin and then run.
 
-Definiendo especificamente `lazy = true`, la cual le dice a lazy que no la incluya directamente solo cuando otro plugin lo llame, util para configurar librerias
+Setting `lazy = true` explicitly tells lazy not to load the plugin until another plugin requires it, which is useful for libraries.
 
-La ultima es definiendo por eventos. Los eventos son señales que neovim envia y que en este caso vamos a estar utilizando para triggerear la carga del plugin. En mi configuracion el que utilizo es `VeryLazy` que es un evento de Lazy que indica que ya se cargo neovim y el usuario gano control. Entonces en ese momento se dispara la carga de otros plugins por detras.
-Lo utilizo en mis configuraciones como telescope, lsp, dressing, snippets y completition.
+The last one is loading on events. Events are signals Neovim emits, and here we use them to trigger loading the plugin. In my configuration I use `VeryLazy`, a lazy event that fires once Neovim has loaded and the user has control. At that point other plugins start loading in the background.
+I use it for things like the LSP, snippets and completion.
 
-## Colorscheme, statusline y fuentes
+## Colorscheme, statusline and fonts
 
-El colorscheme es una implementación nativa basada en la paleta de [Solarized Osaka](https://github.com/craftzdog/solarized-osaka.nvim), en `./lua/config/native-colorscheme.lua`.
-La statusline también es nativa (reemplaza a lualine) y usa esa misma paleta, en `./lua/config/statusline.lua`.
-Como fuente utilizo [Victor Mono](https://rubjo.github.io/victor-mono)
-Utilizo el mismo theme para mi terminal Kitty, y la configuracion de la fuente esta en kitty
-Para symbolos utilizo como complemento los symbolos de [NerdFonts](https://www.nerdfonts.com/)
+The colorscheme is a native implementation based on the [Solarized Osaka](https://github.com/craftzdog/solarized-osaka.nvim) palette, in `./lua/config/native-colorscheme.lua`.
+The statusline is native too (it replaces lualine) and uses the same palette, in `./lua/config/statusline.lua`.
+For the font I use [Victor Mono](https://rubjo.github.io/victor-mono).
+I use the same theme in my Kitty terminal, where the font is configured.
+For symbols I complement it with [Nerd Fonts](https://www.nerdfonts.com/).
 
-## LSP soportando lenguajes
+## LSP language support
 
-Neovim implementa un cliente de LSP (language server protocol). Esto nos permite una mayor interaccion con distintos lenguajes sin requerir distintos plugins para cada lenaguaje individual.
-Neovim en si no sabe nada de los lenguajes que le digamos, neovim simplemente sabe como actuar como cliente, esta en nosotros intalar el servidor correspondiente al lenguaje correspondiente y decirle a neovim como queremos interactuar.
-Mi configuración esta separada en las siguientes partes
+Neovim implements an LSP (Language Server Protocol) client. This gives us rich interaction with many languages without needing a different plugin for each one.
+Neovim itself knows nothing about the languages we use; it just knows how to act as a client. It's up to us to install the right server for each language and tell Neovim how we want to interact with it.
+My configuration is split into the following parts:
 
-- `./lua/plugins/lsp.lua`: Aca es donde tengo definidos los paquetes que utilizo relacionado a lsp
-- `./lua/pi/lsp`: en este directorio esta mi configuracion en relacion a esto
-- `./lua/pi/lsp/init.lua`: es el primer archivo en cargar. Registra cada server habilitado usando el cliente nativo de LSP (ya no uso mason, los servidores se instalan con el gestor de paquetes del sistema).
-  Luego aplico la configuracion particular para cada server.
-  Idealmente este archivo no necesesita ser modificado.
-- `./lua/pi/lsp/attach.lua`: este ya es un archivo más interesante, en donde configuro los mappings relacionados a lsp
-  estos solamente van a registrarse para buffers que tengan asociado un servidor de lsp.
-  Aca se pueden cambiar los keybindings o registrar nuevas funciones
-- `./lua/pi/lsp/default.lua` y `./lua/pi/lsp/servers/`: acá llegamos al más importante donde registramos los servidores con los mismos nombres que _lspconfig_ [ref](https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md). En `default.lua` está la lista de servers habilitados; para la mayoria se usa la configuracion por defecto, pero los que necesitan algo adicional tienen su propio archivo en `servers/<nombre>.lua` que devuelve una funcion con los parametros necesarios.
+- `./lua/plugins/lsp.lua`: where I define the LSP-related packages I use.
+- `./lua/pi/lsp`: the directory with my LSP configuration.
+- `./lua/pi/lsp/init.lua`: the first file to load. It registers every enabled server using the native LSP client (I no longer use mason; servers are installed with the system package manager).
+  It then applies each server's specific configuration.
+  Ideally this file doesn't need to be modified.
+- `./lua/pi/lsp/attach.lua`: a more interesting file, where I set up the LSP-related mappings.
+  They're only registered for buffers that have an attached LSP server.
+  This is where you can change keybindings or register new functions.
+- `./lua/pi/lsp/default.lua` and `./lua/pi/lsp/servers/`: the most important part, where servers are registered using the same names as _lspconfig_ ([ref](https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md)). `default.lua` holds the list of enabled servers; most use the default configuration, but those that need something extra have their own `servers/<name>.lua` file returning a function with the required parameters.
 
 ## Treesitter
 
-Uso nvim-treesitter en su rama `main`, que solo instala parsers y provee queries. Highlight, indent, folds e injections los da Neovim de forma nativa; el enganche se hace con un autocomando `FileType` en `./lua/pi/treesitter.lua`, donde también está la lista de parsers que quiero siempre instalados.
+I use nvim-treesitter on its `main` branch, which only installs parsers and provides queries. Highlighting, indentation, folds and injections are provided natively by Neovim; the hook-up is done with a `FileType` autocommand in `./lua/pi/treesitter.lua`, which also holds the list of parsers I always want installed.
 
-## Completition
+## Completion
 
-Como motor de completition utilizo [blink.cmp](https://github.com/saghen/blink.cmp).
-La configuracion se encuentra en `./lua/plugins/completition.lua` donde defino los keymaps y la integracion con las distintas fuentes como lsp, path, luasnip, latex y autocompletado con IA local via [minuet-ai](https://github.com/milanglacier/minuet-ai.nvim) contra un llama-server.
+For completion I use [blink.cmp](https://github.com/saghen/blink.cmp).
+Its configuration is in `./lua/plugins/completition.lua`, where I define the keymaps and the integration with the different sources such as LSP, path, LuaSnip, LaTeX, and local AI completion via [minuet-ai](https://github.com/milanglacier/minuet-ai.nvim) against a llama-server.
 
 ## Snippets
 
-Para snippets utilizo _LuaSnip_, el cual la configuración la mantengo en `./lua/plugins/snippets.lua`.
-Pero en este archivo no mantengo los snippets en si mismos, en este solamente tengo la configuracion de como interactua, los snippets se encuentran en `./lua/pi/snips/ft/` cual carpeta contiene un archivo por cada file type y se registran automaticamente cuando agrego un nuevo archivo (recargar con `<leader><leader>s`, o reiniciar neovim).
+For snippets I use _LuaSnip_, configured in `./lua/plugins/snippets.lua`.
+That file doesn't hold the snippets themselves, only how they behave. The snippets live in `./lua/pi/snips/ft/`, which has one file per filetype; they're registered automatically when I add a new file (reload with `<leader><leader>s`, or restart Neovim).