Mejores extensiones de formateo de Lua para VS Code

Lua no tiene un estándar de estilo impuesto. El parser del lenguaje acepta cualquier indentación válida, cualquier espaciado de operadores y cualquier disposición de bloques - lo que significa que cada desarrollador recurre a sus propios hábitos. En un proyecto en solitario está bien. En una base de código compartida, un mod de juego o un repositorio de scripts de equipo, el formato inconsistente genera ruido en cada diff, ralentiza la revisión de código y hace la depuración más difícil de lo necesario.

El coste de un estilo de Lua inconsistente

Cuando dos personas escriben Lua de forma distinta - una usa indentación de cuatro espacios, otra tabulaciones; una espacia alrededor de los operadores, la otra no - cada commit contiene cambios de formato mezclados con cambios de lógica. Los revisores dedican tiempo a leer diffs de estilo en lugar de diffs de lógica. Los conflictos de fusión se disparan. Un formateador lo resuelve normalizando cada archivo al mismo estilo al guardar, haciendo los diffs limpios y revisables.

• Indentación consistente - los bloques `do`/`end`, `if`/`end`, `function`/`end` se indentan siempre de la misma manera
• Espaciado uniforme - los espacios alrededor de `=`, `+`, `-`, `..` y otros operadores se aplican de forma consistente
• Disciplina de líneas en blanco - las líneas en blanco extra entre funciones y dentro de los bucles se normalizan automáticamente
• Manejo legible de cadenas - las concatenaciones largas y las cadenas multilínea se disponen de forma predecible
• Aplicación a nivel de equipo - un `.luarc.json` o `stylua.toml` compartido en el control de versiones garantiza que todos usen las mismas reglas

El Marketplace de VS Code tiene varias extensiones de Lua, pero solo unas pocas se mantienen activamente y ofrecen un formateo fiable. Estas son las tres que vale la pena conocer en 2026, por orden de recomendación.

1. Lua Language Server (sumneko.lua) - recomendada

El Lua Language Server, publicado como `sumneko.lua` en el Marketplace de VS Code, es la herramienta de desarrollo de Lua más completa disponible para VS Code. Instala una implementación completa del Protocolo de Servidor de Lenguaje (LSP) que ofrece diagnósticos, inferencia de tipos, ir a definición, documentación al pasar el ratón, búsqueda de referencias en todo el workspace y un formateador integrado - todo en una sola extensión.

• Editor: sumneko (Tang Liu)
• ID del Marketplace: `sumneko.lua`
• Instalaciones activas: 1M+ (a fecha de 2026)
• Versiones de Lua soportadas: 5.1, 5.2, 5.3, 5.4, LuaJIT
• Formateador: Integrado, configurado vía `.luarc.json`
• Formato al guardar: Soportado de forma nativa
• Ideal para: La mayoría de flujos de trabajo de Lua - scripting de juegos, herramientas independientes, sistemas embebidos

2. StyLua (jq-steuersoftware.stylua) - alternativa con estilo propio

StyLua es un formateador de código Lua con estilo propio, escrito en Rust e inspirado en Prettier. La extensión de VS Code envuelve el binario de StyLua y lo integra como formateador de documentos. A diferencia del Lua Language Server, StyLua es solo un formateador - no ofrece diagnósticos, documentación al pasar el ratón ni autocompletado. Lo que aporta es un estilo determinista y sin debates: aceptas el estilo y te comprometes con él, igual que funciona Prettier para JavaScript.

• Editor: jq-steuersoftware
• ID del Marketplace: `jq-steuersoftware.stylua`
• Versiones de Lua soportadas: 5.1, 5.2, 5.3, 5.4, LuaJIT, Luau (Roblox)
• Archivo de configuración: `stylua.toml` (opcional - funciona bien con los valores por defecto)
• Formato al guardar: Soportado de forma nativa
• Ideal para: Proyectos nuevos, equipos que quieren formateo tipo Prettier sin configuración, desarrollo de Luau en Roblox

3. LuaFormatter (Koihik.vscode-lua-format) - opción heredada configurable

LuaFormatter es una extensión más antigua que envuelve la herramienta de línea de comandos `lua-format`. Ofrece una configuración amplia - puedes ajustar individualmente el ancho de indentación, la longitud máxima de línea, el espaciado de operadores, la indentación de continuación y muchas otras reglas. Ese nivel de control lo hace útil al migrar una base de código existente que ya tiene una convención de estilo establecida que el formateador debe respetar. Sin embargo, su desarrollo se ha ralentizado desde que surgió StyLua, y el binario `lua-format` requiere un paso de instalación aparte en algunas plataformas.

• Editor: Koihik
• ID del Marketplace: `Koihik.vscode-lua-format`
• Archivo de configuración: `.lua-format` (formato YAML)
• Ideal para: Bases de código existentes con requisitos de estilo complejos, control granular por regla
• Aviso: Requiere el binario `lua-format` instalado aparte en Linux/Mac

Instalar el Lua Language Server lleva menos de dos minutos. Esta es la ruta completa de configuración desde una instalación fresca de VS Code hasta el formato al guardar funcionando.

{
  "Lua.runtime.version": "Lua 5.4",
  "Lua.diagnostics.globals": ["myGlobal", "anotherGlobal"],
  "Lua.format.enable": true,
  "Lua.format.defaultConfig": {
    "indent_style": "space",
    "indent_size": "4",
    "max_line_length": "120",
    "trailing_table_separator": "smart"
  }
}

{
  "editor.formatOnSave": true,
  "[lua]": {
    "editor.defaultFormatter": "sumneko.lua"
  }
}

El formato al guardar es el ajuste individual de mayor impacto que puedes activar para el desarrollo de Lua en VS Code. Una vez activo, nunca accionas el formateador manualmente - se ejecuta cada vez que pulsas Ctrl+S. Así se configura correctamente para distintos escenarios de equipo.

Ajustes de usuario frente a ajustes de workspace

VS Code tiene dos niveles de configuración: a nivel de usuario (se aplica a todos los proyectos) y a nivel de workspace (solo al proyecto actual). Para el formateo, el nivel de workspace casi siempre es la elección correcta - garantiza que cada colaborador del proyecto use el mismo formateador, sin importar sus preferencias personales a nivel de usuario. Los ajustes de workspace viven en `.vscode/settings.json` en la raíz del proyecto y deberían subirse al control de versiones.

Formato al guardar con StyLua

La extensión de StyLua para VS Code usa el mismo mecanismo de formato al guardar. Fija el formateador por defecto en `jq-steuersoftware.stylua` en los ajustes de tu workspace. StyLua lee un archivo de configuración `stylua.toml` si existe - allí defines column_width, indent_type, indent_width y quote_style. Sin `stylua.toml`, StyLua aplica sus reglas por defecto (indentación de dos espacios, longitud de línea de 120 caracteres, comillas dobles).

column_width = 120
line_endings = "Unix"
indent_type = "Spaces"
indent_width = 4
quote_style = "AutoPreferDouble"
call_parentheses = "Always"

Excluir archivos del formateo

Algunos archivos Lua no deberían reformatearse - librerías de terceros, código generado o scripts minificados. En StyLua, añade un archivo `.styluaignore` (misma sintaxis que `.gitignore`) para excluir rutas. En el Lua Language Server, puedes acotar el formateador a directorios específicos con el ajuste `Lua.workspace.ignoreDir` en `.luarc.json`.

Los dos formateadores de Lua más discutidos son LuaFormatter y StyLua. Adoptan filosofías de formateo fundamentalmente distintas y la elección correcta depende del contexto de tu proyecto. Aquí tienes una comparación directa.

Si empiezas un proyecto nuevo, elige StyLua y sube la configuración. Si heredas una base de código con un estilo ya establecido, configura LuaFormatter para respetarlo. Nunca mezcles ambos formateadores en la misma base de código.

Lua Language Server frente a StyLua: ¿pueden coexistir?

El Lua Language Server y StyLua cumplen propósitos principales distintos - Lua LS es un language server completo para diagnósticos e intellisense, y StyLua es solo un formateador. Pueden coexistir en la misma configuración de VS Code: instala Lua LS para diagnósticos e inteligencia de código, y fija StyLua como formateador por defecto para el formateo de documentos. Esta combinación te da lo mejor de ambos. Configúralo en .vscode/settings.json fijando el defaultFormatter de [lua] a jq-steuersoftware.stylua mientras mantienes Lua LS instalado por sus funciones LSP.

El formateador integrado de Lua LS: cuándo basta

Para la mayoría de los desarrolladores, el formateador integrado del Lua Language Server es suficiente y elimina la necesidad de instalar una segunda extensión. Cubre todas las tareas de formateo estándar y se integra limpiamente con `.luarc.json`. La razón principal para añadir StyLua encima es que tu equipo quiera una aplicación de estilo más fuerte (p. ej. imponer un estilo de comillas o convenciones de paréntesis en llamadas) que el formateador de Lua LS no soporta actualmente.

Las extensiones de VS Code son la solución correcta para el desarrollo diario. Pero hay escenarios en los que necesitas formatear código Lua sin instalar nada en absoluto - y ahí es donde una herramienta basada en navegador cubre el hueco con elegancia.

Cuando no puedes instalar extensiones

• Equipos compartidos o restringidos - estaciones de trabajo corporativas, ordenadores de laboratorio o entornos de CI donde no puedes instalar extensiones de VS Code
• Limpieza puntual - un colega te envía un fragmento de Lua para revisar y quieres formatearlo sin cambiar de contexto
• Revisión de código sin entorno de desarrollo - revisar un pull request en una máquina donde tu configuración completa de Lua no está instalada
• Comprobaciones de onboarding - verificar que un archivo se ve bien formateado antes de hacer commit sin esperar a que se instale toda la cadena de herramientas
• Inspección de código minificado - tienes una salida del minificador de Lua y quieres reformatearla para leerla

El Formateador de Lua de Aback Tools cubre todos estos casos. Pega tu código Lua en el editor y el formateador aplica indentación consistente, normaliza el espaciado de operadores y limpia las líneas en blanco en tu navegador - sin registro, sin instalación y sin que tus datos salgan de tu dispositivo.

Herramientas de Lua online complementarias

El formateo es un paso de un flujo completo de calidad de código Lua. Varias otras herramientas de navegador cubren tareas vecinas que necesitarás con frecuencia junto al formateo:

• **Lua Beautifier** - se centra en mejorar la disposición visual de código sintácticamente correcto pero difícil de leer
• **Validador de sintaxis de Lua** - comprueba el código en busca de errores a nivel de parser con diagnósticos por línea antes de ejecutarlo
• **Minificador de Lua** - elimina comentarios, espacios y líneas en blanco para despliegue en producción y reducir el tamaño del script
• **Ofuscador de Lua** - renombra variables y codifica cadenas para proteger scripts de juego de la ingeniería inversa casual
• **Asistente de desofuscación de Lua** - mejora la legibilidad de scripts ofuscados para flujos de depuración y análisis

Un formateador se encarga del espaciado, pero la buena calidad del código Lua va más allá. Estas prácticas trabajan junto a tu formateador para mantener las bases de código Lua consistentes, legibles y mantenibles a cualquier escala.

Sube la configuración de tu formateador al control de versiones

Un `.luarc.json` para Lua LS, `stylua.toml` para StyLua o `.lua-format` para LuaFormatter deben vivir en la raíz del proyecto y subirse a tu repositorio. Esto garantiza que cada colaborador - y cada ejecución de CI - use las mismas reglas de formateo. Sin una configuración subida, cada desarrollador recurre a los ajustes de su propia extensión y la divergencia de formato vuelve a colarse con el tiempo.

Añade una comprobación de formato en CI

El formato al guardar en VS Code solo ayuda a quien usa VS Code con la extensión instalada. Una comprobación de CI detecta lo que se cuela - colaboradores con otros editores, archivos parcheados a las prisas o código Lua generado. La bandera `--check` de StyLua sale con código distinto de cero si algún archivo no está bien formateado, lo que facilita hacer fallar un job de GitHub Actions o GitLab CI por infracciones de estilo.

Separa los commits de formato de los commits de lógica

Si introduces un formateador por primera vez en una base de código existente, ejecuta el formateador sobre todos los archivos en un único commit dedicado sin otros cambios. Etiquétalo con claridad (p. ej. `chore: apply lua formatter to all files`). Así el ruido de formato queda en un commit y todos los commits posteriores contienen solo cambios de lógica - y `git blame` sigue siendo útil en cada línea.

Usa una nomenclatura consistente para variables locales

Los formateadores no renombran variables - esa es tu responsabilidad. La comunidad de Lua sigue mayoritariamente `snake_case` para variables y funciones y `PascalCase` para tablas a nivel de módulo y constructos tipo clase. Acorda una convención con tu equipo y documéntala en el `CONTRIBUTING.md` de tu proyecto. Si trabajas con Roblox Luau, la guía de estilo de Roblox especifica `PascalCase` para instancias y servicios y `camelCase` para variables locales - ten presente la distinción antes de aplicar convenciones de la comunidad de Lua a ciegas.