Before the Language Server Protocol, every editor that wanted good Java or Python support reimplemented the same expensive ideas: parse the project, walk types, compute completions, format, rename. Language vendors shipped plugins that were glued to Eclipse, IntelliJ, or Vim internals. Multiply editors by languages and the matrix is unmaintainable. VS Code's team, working with the TypeScript language service experience in mind, specified a JSON-RPC protocol so an editor could be a thin client and a language server could own analysis. OmniSharp, the TypeScript server, clangd, rust-analyzer, and dozens of others became reusable processes. Microsoft published LSP as an open specification; the win for VS Code was also a win for every editor willing to speak it.
The M×N problem and a process boundary
An in-process plugin is fast and dangerous. A crash in the type checker takes down the editor. A language implemented in a different runtime than the editor (C# vs. Electron, Rust vs. Vim) forces awkward embeddings. LSP makes the language implementation a separate process with a documented set of requests: textDocument/completion, definition, hover, references, diagnostics pushed as notifications. The editor sends document snapshots and change events; the server returns locations and lists. That process boundary is why a memory leak in a Java language server does not kill the window, and why the same server binary can sit behind VS Code, Neovim, and Emacs.
Versioning the protocol is a product problem. Editors and servers ship on independent clocks. Capabilities are negotiated at initialize time so an old server can ignore inlay hints and a new editor can skip unimplemented requests. Teams that skip capability checks and assume the latest LSP feature set ship "works on my VS Code" extensions.
Latency, files, and the ways servers lie
A language server that re-parses the world on every keystroke will feel worse than a native plugin. Incremental parsing, file watching, and "didChange" vs. full document sync are the real engineering. VS Code's guide is explicit: prefer incremental updates, debounce diagnostics, and do not block completions on a full project typecheck if a local syntactic list is available. Those are the same techniques TypeScript's own language service honed inside Microsoft before they were generalized.
Workspace scale is the failure mode that demos hide. A monorepo with thousands of packages can make references a multi-minute walk unless the server has an index. Multi-root workspaces, remote SSH, and WSL add filesystem and latency twists: the server must run near the files, which is why VS Code's remote model installs servers on the other side of the SSH hop rather than shipping every completion over the WAN as raw source. Incorrect URI encoding, Windows vs. POSIX paths, and stale file versions (the client edited, the server analyzed an old snapshot) produce wrong go-to-definition that users file as editor bugs.
The industry borrow is larger than IDEs. Any rich client that needs expensive domain analysis — CAD, data catalogs, game scene graphs — can split "view" from "intelligence process" with a versioned RPC, capability flags, and incremental snapshots. LSP succeeded because Microsoft did not keep the protocol VS Code-only and because language teams would rather maintain one server than five plugins.
What you can borrow
- Put crashy, language-specific analysis in a child process with a small, versioned RPC surface.
- Negotiate capabilities; never assume both sides shipped the same week.
- Incremental document sync and indexes beat full reparse; measure completion latency on a real repo, not a toy file.
- Run the analyzer next to the files in remote workflows; do not pull whole trees to the UI host.
- Treat path and version skew as protocol bugs. Wrong locations destroy trust faster than missing features.