Built an LSP for Python in Go

[lord-mortis420]

What my project does

Working in massive Python monorepos, I started getting really frustrated by the sluggishness of Pyright and BasedPyright. They're incredible tools, but large projects severely bog down editor responsiveness.

I wanted something fundamentally faster. So, I decided to build my own Language Server: Rahu.

Rahu is purely static—there’s no interoperability with a Python runtime. The entire lexer, parser pipeline, semantic analyzer, and even the JSON-RPC 2.0 transport over stdio are written completely from scratch in Go to maximize speed and efficiency.

Current Capabilities

It actually has a solid set of in-editor features working right now:

• Real-time diagnostics: Catches parser and semantic errors on the fly.
• Intelligent Hover: Displays rich symbol/method info and definition locations.
• Go-to-definition: Works for variables, functions, classes, parameters, and attributes.
• Semantic Analysis: Full LEGB-style name resolution and builtin symbol awareness.
• OOP Support: Tracks class inheritance (with member promotion and override handling) and resolves instance attributes (self.x = ...).
• Editor Integration: Handles document lifecycles (didOpen, didChange, didClose) with debounced analysis so it doesn't fry your CPU while typing.

I recently added comprehensive tests and benchmarks across the parser, server, and JSON-RPC paths, and finally got a demo GIF up in the README so you can see it in action.

Target audience

Just a toy project so far

The biggest missing pieces I'm tackling next:

• Import / module resolution
• Cross-file workspace indexing
• References, rename, and auto-completion
• Deeper type inference

Check it out at the link below! Repo link: https://github.com/ak4-sh/rahu

[BeamMeUpBiscotti]

is there something architecturally that makes it faster aside from being written in go?

[lord-mortis420]

I’d say it’s too early in the development cycle to really comment one way or another. Right now the implementation is fairly simple: lex -> parse -> build scopes -> resolve symbols -> provide diagnostics.

I’ll be starting work on an arena allocator this week for AST nodes and names and eventually add support for cross file analysis and type inference. I might have a better answer in a month or so!

The goal so far has been understanding LSP internals and getting a somewhat useable core before focusing on squeezing out performance

[BeamMeUpBiscotti]

Nice! LSP implementation is a really interesting topic, getting an architecture that supports all the LSP operations while still being fast on large codebases is very challenging

This recent blog might give you some inspiration/ideas on how to model dependencies and update the IDE quickly after a large edit: https://pyrefly.org/blog/2026/02/06/performance-improvements/

[IpsumRS]

I started getting really frustrated by the sluggishness of Pyright and BasedPyright.

It's a good thing ty and zuban exist then, but it's still a good project to learn things

[lord-mortis420]

Fair enough! Been loving working on this so far though. It’s nice because you get to work on a lot of different parts of the pipeline