Language Support#
Serena provides a set of versatile code querying and editing functionalities based on symbolic understanding of the code across a wide range of programming languages. Equipped with these capabilities, Serena discovers and edits code just like a seasoned developer making use of an IDE’s capabilities would. Serena can efficiently find the right context and do the right thing even in very large and complex projects!
There are two alternative technologies powering these capabilities:
Language servers implementing the language server Protocol (LSP) — the free/open-source alternative.
The Serena JetBrains Plugin, which leverages the powerful code analysis and editing capabilities of your JetBrains IDE.
See the Features section for a detailed comparison of the capabilities provided by the JetBrains Plugin vs. language servers.
Language Servers#
Serena incorporates a powerful abstraction layer for the integration of language servers that implement the language server protocol (LSP). It even supports multiple language servers in parallel to support polyglot projects.
The language servers themselves are typically open-source projects (like Serena) or at least freely available for use.
We currently provide direct, out-of-the-box support for the programming languages listed below. Some languages require additional installations or setup steps, as noted.
Ada / SPARK#
(uses AdaCore’s Ada Language Server (ALS),
automatically downloaded; supports .ads, .adb, and .ada files;
works best with a .gpr GNAT project file at the repository root;
SPARK is handled by the same server transparently — set language ada for both.
To use a pre-installed ALS (e.g. from Alire, GNAT Studio, or the VS Code Ada extension),
set ls_specific_settings.ada.ls_path.)
AL#
(uses the AL Language Server from Microsoft’s AL extension for VS Code (ms-dynamics-smb.al), automatically downloaded from the VS Code Marketplace)
Angular#
(experimental; uses the official @angular/language-server (ngserver), automatically installed via npm; requires Node.js + npm, plus npm install having been run in the project root so that @angular/core
is resolvable — without it, template-aware features silently return empty;
subsumes typescript and html for .ts/.html files, so do not also list those)
Ansible#
(experimental; requires Node.js and npm; automatically installs @ansible/ansible-language-server;
must be explicitly specified in the languages entry in the project.yml; requires ansible in PATH for full functionality)
the upstream @ansible/ansible-language-server@1.2.3 supports hover, completion, definition,
semantic tokens, and validation; document symbols, workspace symbols, references, and rename
are not supported by this version)
Bash#
(uses bash-language-server, automatically installed via npm; requires Node.js and npm on PATH; a pinned ShellCheck binary is downloaded automatically)
BSL (1C:Enterprise / OneScript)#
(requires Java 21+ on PATH; uses bsl-language-server by 1c-syntax; the JAR is auto-downloaded and SHA-256-verified for the bundled default version; supports .bsl and .os files; configure optional ls_path or bsl_ls_version under ls_specific_settings.bsl)
C##
(by default, uses the Roslyn language server (language csharp), requiring .NET v10+ and, on Windows, pwsh (PowerShell 7+);
set language to csharp_omnisharp to use OmiSharp instead)
C/C++#
(by default, uses the clangd language server (language cpp) but we also support ccls (language cpp_ccls);
for best results, provide a compile_commands.json at the repository root;
see the C/C++ Setup Guide for details;
for Unreal Engine 5 projects, see the Unreal Engine Setup Guide.)
Clojure#
(uses clojure-lsp, automatically downloaded; requires the Clojure CLI to be installed)
Crystal#
(requires Crystalline language server to be installed and available on PATH; note: Crystalline has limited go-to-definition support and does not support find-references)
CUE#
(uses cue lsp from the official cue binary, automatically downloaded)
Dart#
(uses the Dart SDK’s built-in language server (dart language-server); the SDK is downloaded automatically)
Elixir#
(requires Elixir installation; Expert language server is downloaded automatically)
Elm#
(requires Elm compiler; uses elm-language-server, installed automatically via npm)
Erlang#
(requires installation of beam and erlang_ls; experimental, might be slow or hang;
note that functions are addressed as name#arity, e.g. create_user#4, because / is reserved as the name path separator)
F##
(requires .NET v8.0+; uses FsAutoComplete/Ionide, which is auto-installed; for Homebrew .NET on macOS, set DOTNET_ROOT in your environment)
Fortran#
(uses fortls, run automatically via uvx; requires uv/uvx in PATH)
GDScript (Godot Engine)#
(requires the Godot editor to be running with its built-in LSP enabled — default on port 6008; Serena connects over TCP and does not launch Godot itself; see the GDScript Setup Guide for details)
Gleam#
(requires the Gleam compiler on PATH; the language server is bundled with the compiler and started via gleam lsp)
Go#
(requires installation of gopls)
Groovy#
(requires local groovy-language-server.jar setup via GROOVY_LS_JAR_PATH or configuration)
Haskell#
(automatically locates HLS via ghcup, stack, or system PATH; supports Stack and Cabal projects)
Haxe#
(requires Haxe compiler 3.4.0+ and Node.js; uses the vshaxe language server; automatically downloaded from Open VSX, or discovered from the vshaxe VSCode extension)
HLSL / GLSL / WGSL#
(uses shader-language-server (language hlsl); automatically downloaded;
on macOS, requires Rust toolchain for building from source;
note: reference search is not supported by this language server)
HTML#
(experimental; requires Node.js + npm; automatically installs vscode-html-language-server via the vscode-langservers-extracted npm package)
Java#
(uses Eclipse JDT LS via the vscode-java extension bundle, automatically downloaded with a bundled JRE)
JavaScript#
(supported via the TypeScript language server, i.e. use language typescript for both JavaScript and TypeScript)
Julia#
(requires a Julia installation; uses LanguageServer.jl, automatically installed via Pkg if missing)
Kotlin#
(uses the pre-alpha official kotlin LS, some issues may appear)
LaTeX#
(experimental; must be explicitly enabled via language latex; uses texlab,
auto-downloaded as a SHA-256-verified prebuilt binary; supports .tex, .bib, .sty, and .cls files; texlab is
GPL-3.0 and runs as a separate downloaded process)
Lean 4#
(requires lean and lake installed via elan; uses the built-in Lean 4 LSP;
the project must be a Lake project with lake build run before use)
Lua#
(uses lua-language-server, taken from PATH if present, otherwise downloaded automatically)
Luau#
(uses luau-lsp, taken from PATH or automatically downloaded)
Markdown#
(uses Marksman, automatically downloaded; must explicitly enable language markdown, primarily useful for documentation-heavy projects)
MATLAB#
(requires Node.js and a licensed local MATLAB installation, R2021b or later; Serena automatically downloads version 1.3.9 of the VS Code MATLAB extension, which bundles the MATLAB language server)
mSL (mIRC Scripting Language)#
(auto-installed; no external dependencies required — uses a custom pygls-based LSP server shipped with Serena;
supports document symbols, workspace symbols, references, and go-to-definition for aliases, events, menus, dialogs, and CTCP handlers in .mrc files)
Nextflow#
(uses the official Nextflow language server, which is automatically
downloaded; requires a Java 17+ runtime, discovered via ls_specific_settings.nextflow.java_home, JAVA_HOME or java on PATH;
covers .nf scripts — Nextflow .config files are not treated as source files, since the language server reports no symbols for them;
processes, workflows and functions are reported under their declared name, e.g. GREET for process GREET)
Nix#
(requires nixd installation)
OCaml#
(requires opam and ocaml-lsp-server to be installed manually; see the OCaml Setup Guide)
Pascal#
(uses the Pascal/Lazarus language server (pasls), which is automatically downloaded; set PP and FPCDIR environment variables for source navigation)
Perl#
(requires installation of Perl::LanguageServer)
PHP#
(by default, uses the Intelephense language server (language php), set INTELEPHENSE_LICENSE_KEY environment variable for premium features;
we also support Phpactor (language php_phpactor), which requires PHP 8.1+;
and the experimental PHPantom backend (language php_phpantom)
PowerShell#
(requires PowerShell 7+ (pwsh) on PATH or in a standard install location; Serena automatically downloads PowerShell Editor Services 4.4.0 and installs PSScriptAnalyzer 1.25.0 via Save-Module from your configured PowerShell repository)
Python#
(by default, uses Pyright (language python);
alternatives: BasedPyright (language python_basedpyright),
ty (language python_ty),
pyrefly (language python_pyrefly),
Jedi (language python_jedi);
Pyright, BasedPyright, ty, and pyrefly require uv/uvx in PATH)
QML#
(requires Qt 6, provides qmlls or qmlls6 on PATH; see the Qt qmlls documentation)
R#
(requires installation of the languageserver R package)
Rego#
(requires the Regal language server on PATH)
Ruby#
(by default, uses ruby-lsp (language ruby); use language ruby_solargraph to use Solargraph instead.)
Rust#
(requires rustup - uses rust-analyzer from your toolchain)
Scala#
(uses Metals LSP, which imports the build on first use — see the setup guide)
SCSS / Sass / CSS#
(experimental; requires Node.js + npm; uses some-sass-language-server to handle
.scss, .sass, and .css)
Solidity#
(experimental; requires Node.js and npm; automatically installs @nomicfoundation/solidity-language-server;
works best with a foundry.toml or hardhat.config.js in the project root)
Svelte#
(requires Node.js v18+ and npm; supports .svelte Single File Components plus TypeScript/JavaScript files via svelte-language-server; a companion typescript-language-server + typescript-svelte-plugin is spawned automatically for cross-file rename, go-to-definition, and references across .ts/.js and .svelte files; use language svelte for Svelte projects instead of also enabling typescript)
Swift#
(uses sourcekit-lsp, which must be installed and available on your PATH)
SystemVerilog#
(uses verible-verilog-ls, taken from PATH if present, otherwise version v0.0-4051-g9fdb4057 is downloaded automatically)
Terraform#
(uses terraform-ls 0.36.5, which Serena downloads automatically; requires Terraform on PATH)
TOML#
(experimental; uses Taplo 0.10.0, taken from PATH if present, otherwise downloaded automatically)
TypeScript#
(uses typescript-language-server together with the typescript package, both installed automatically via npm; requires Node.js and npm)
Deno#
(experimental; requires the deno CLI on PATH — it bundles the language server used here;
serves Deno TypeScript/JavaScript and understands npm: / jsr: / https: imports and the Deno.*
globals, which the plain TypeScript language server does not; overlaps typescript on file extensions,
so it is not auto-detected and must be set as the language explicitly — do not also enable typescript
for the same files)
Vue#
(3.x with TypeScript; uses @vue/language-server (Volar), installed automatically via npm; requires Node.js v18+ and npm; supports .vue Single File Components with monorepo detection)
Wolfram Language#
(requires Wolfram Mathematica 13.0+ or Wolfram Engine 12.1+; uses the official WolframResearch LSPServer paclet; supports .wl and .wls files; references are within-file only)
YAML#
(experimental; uses yaml-language-server (Red Hat), installed automatically via npm; requires Node.js and npm)
JSON#
(experimental; uses vscode-json-languageserver (Microsoft), installed automatically via npm; must be explicitly added to the languages list; requires Node.js and npm)
Zig#
(requires installation of ZLS - Zig Language Server)
Support for further languages can easily be added by providing a shallow adapter for a new language server implementation, see Serena’s memory on that.
The Serena JetBrains Plugin#
The Serena JetBrains Plugin leverages the powerful code analysis capabilities of JetBrains IDEs. The plugin naturally supports all programming languages and frameworks that are supported by JetBrains IDEs.
When using the plugin, Serena connects to an instance of your JetBrains IDE via the plugin. For users who already work in a JetBrains IDE, this means Serena seamlessly integrates with the IDE instance you typically have open anyway, requiring no additional setup or configuration beyond the plugin itself.
See the JetBrains Plugin documentation for a high-level overview of its benefits and usage details.
See the Features section for a detailed comparison of the capabilities provided by the JetBrains Plugin vs. language servers.
