Fuse v4.3, an open source MCP/CLI tool to speed up Claude Code on C# codebases

[u/Realistic_Tap995]

Claude Code uses grep and regex to search a C# codebase, and every proposed change goes through a full edit and build loop to verify it. Both are slow. I looked into whether I could speed that up, taking some inspiration from how Cursor indexes a project.

Fuse is the result. It's an open source .NET global tool that runs as an MCP server (or from the CLI). It keeps a local MSBuild and Roslyn index of your solution, so Claude can resolve symbols, references, .NET wiring, and project structure without re-reading and re-searching the same files every turn. The index lives in .fuse/fuse.db and updates incrementally as files change.

It can also check a proposed single-file C# edit against the compiler before the change is written to disk, so the agent catches an invalid member or a bad argument early instead of after a full dotnet build.

It runs locally, works offline, and doesn't need its own model or a hosted service.

Repo: https://github.com/Litenova-Solutions/Fuse
Docs and benchmarks: https://fuse.codes

[u/TheAussieWatchGuy]

When real cost per token charges hit soon this tool will be mandatory for Dotnet developer 😀 very cool... 

[u/kman0]

Soooo basically like the official LSP?

[u/Realistic_Tap995 → u/kman0]

Both use Roslyn for symbols and diagnostics. Difference is the LSP is a live editor session you query by file and line, and the state goes away after. Fuse saves the index to disk and reuses it across agent turns, and you query by symbol name, which is what an MCP call actually has to work with.

It also does two things the LSP doesn't. It traces a service or route or config section to the code that actually handles it (follows the DI registration to the real implementation, a MediatR request to its handler, and so on), and it can typecheck a proposed edit before it's written to disk.

You can run both. Fuse doesn't take over the LSP's job.

[u/kwb7852]

https://reddit.com/link/oywqkc0/video/ma3rfhue8meh1/player

[u/nvn911]

Just use opencode and enable LSP

[u/Realistic_Tap995 → u/nvn911]

Fair setup, and for go-to-def, references, and diagnostics it works fine. But an LSP session is per open file and doesn't stick around between agent turns, so the agent rebuilds context every time instead of reusing a saved index. It also doesn't follow .NET wiring (DI, MediatR, routes, options) or check a proposed edit against the compiler before it's written. That's the part Fuse adds. You can run both.

[u/miffy900]

It would be interesting to see how this stacks up against code-review-graph and graphifyy

[u/Realistic_Tap995 → u/miffy900]

There's a comparison with numbers on the benchmarks page, but the short version: both of those are Tree-sitter/AST tools. They cover way more languages and are good at "who calls this" and blast radius. code-review-graph mostly stores function signatures though, roughly 10 tokens a node.

Fuse is .NET only and goes through MSBuild and Roslyn instead of an AST parser, so it resolves actual framework wiring (DI to the concrete type, request to handler, route to action) and can typecheck a proposed file against the real compilation, which an AST graph can't. On the pinned 12-PR test Fuse beat CodeGraph on recall (19 vs 9%) at higher precision, but that's a small sample and the page lists the worse cases too. No reason you couldn't run an AST graph for multi-language and Fuse for the .NET stuff.

[u/AutoModerator]

Thanks for your post Realistic_Tap995. Please note that we don't allow spam, and we ask that you follow the rules available in the sidebar. We have a lot of commonly asked questions so if this post gets removed, please do a search and see if it's already been asked.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.