ILSpy Alternative: When You Want More

Let me start with something you do not always hear from a company that ships a competing tool: ILSpy is genuinely good. It is free, open source, actively maintained, and its decompiler engine is the reference the rest of us build on. If someone asks me for a solid free .NET decompiler and nothing else, ILSpy is a completely defensible answer.

So why would you look for an alternative? Not because ILSpy decompiles badly — it does not. Usually it is because you want more around the code: a smoother UI, tighter navigation, a workflow that feels like moving through your own project rather than browsing a tree. This post is an honest look at where people want more from ILSpy, and how the alternatives — including Glass.NET, which I work on — stack up.

TL;DR: ILSpy's decompilation is excellent and its engine powers several other tools, Glass.NET included. If you are happy with ILSpy, stay. If you want a more Visual-Studio-like UI and a navigation-first workflow on top of the same decompilation quality, Glass.NET is worth a look. If you live in JetBrains tools, dotPeek fits. All three are free.

What ILSpy is great at

Credit where it is due. ILSpy earns its place:

• Accurate, modern C#. The ICSharpCode.Decompiler engine (MIT-licensed) stays current with new language features — async/await, pattern matching, records, and more come back intact.
• Free and open source. No cost, no sign-up, and you can read the source of the decompiler itself.
• Actively maintained. Unlike dnSpy, which is archived, ILSpy gets ongoing updates.
• Lean and trustworthy. It does the core job — browse types, read C# and IL, export a project — without a lot of ceremony.
• A shared foundation. Because the engine is open, tools like Glass build on it. When you use Glass, you are getting ILSpy-quality decompilation with a different front end.

That last point matters for this whole comparison: this is not a fight about who reconstructs C# more accurately. On engine-shared tools, the C# is comparable. The question is what the tool gives you around the code.

Where people want more

Over and over, the reasons people look past ILSpy are about experience, not accuracy:

• A more Visual-Studio-like UI. ILSpy's interface is functional but lean. Developers who spend their day in VS often want an editor that looks and behaves like the one they already know.
• Navigation that keeps up. Reading one method is easy. Understanding how a large assembly fits together means jumping to definitions, finding every caller, and not losing your place. People want that to feel instant and cohesive.
• Orientation in big assemblies. A breadcrumb, navigation history, and a fast fuzzy quick-open make a 3,000-type assembly feel navigable instead of overwhelming.
• Comparison and export niceties. Diffing two versions of an assembly, or exporting a clean buildable project, sometimes wants a bit more polish than a lean reader offers.

None of these are knocks on ILSpy's core job. They are all "I want the reading experience to feel like my IDE."

Glass.NET: the same engine, a navigation-first UI

Here is the honest pitch for Glass.NET. It is free, and it is built on the same ICSharpCode.Decompiler engine as ILSpy — so the decompiled C# is on par. I am not going to tell you our decompilation is smarter, because it is the same engine. What Glass adds is the experience:

• A Visual-Studio-native, Avalonia-based UI with a real code editor, code folding, syntax highlighting, and matching light and dark themes.
• Go to Definition (F12) and Find All References (Shift+F12), resolved from the decompiler's own syntax tree so you land on the right symbol, not a text match.
• Go To All (Ctrl+T) — fuzzy quick-open across every type and member in the assembly.
• Call and type hierarchy to walk callers/callees and base/derived types.
• Breadcrumbs and navigation history, so you always know where you are and can step back.
• C# and IL views, and export to a buildable project when you want the code on disk.
• Static analysis only — Glass never runs the assembly it inspects.

If ILSpy's decompilation is what you like but the reading experience is what you want more of, that is exactly the gap Glass is built to fill. There is a full feature-by-feature breakdown in Glass.NET vs ILSpy, dnSpy and dotPeek.

dotPeek: the JetBrains alternative

The other serious free option is dotPeek from JetBrains. Unlike Glass and ILSpy, it uses JetBrains' own decompiler engine rather than ICSharpCode.Decompiler. It integrates with ReSharper and can act as a symbol server, letting Visual Studio step into decompiled code. If you already work in JetBrains tools, it is a natural fit. There is a dedicated dotPeek alternative comparison if you are weighing it specifically.

A quick side-by-side

The row that matters most: decompiled C# quality is comparable across ILSpy and Glass because it is literally the same engine. Pick on UI and workflow, not on decompilation.

A worked example: navigating, not scrolling

Suppose you open a 2,000-type assembly to understand how its PaymentProcessor validates input. In a lean reader you expand the tree, find the type, read the method, then manually hunt for what calls Validate(). In a navigation-first tool the flow is: Ctrl+T, type PaymentProcessor, Enter; F12 on Validate to land on its definition; Shift+F12 to stream every caller into a results panel:

private bool Validate(PaymentRequest req)
{
    if (req.Amount <= 0m) return false;
    if (string.IsNullOrEmpty(req.Currency)) return false;
    return _rules.All(rule => rule.IsSatisfiedBy(req));
}

F12 on IsSatisfiedBy walks you into each rule implementation. You are moving through the assembly the way you move through your own project — that is the "more" people are usually after.

Honest limits

Whichever tool you pick, decompilation is decompilation. You get accurate C# for what the code does, but comments are gone, most local variable names are lost unless a PDB supplies them, and constructs like async state machines are reconstructed rather than recovered verbatim. And none of ILSpy, Glass or dotPeek is a live debugger — for that, dnSpyEx is the community-maintained tool. Only analyze software you have the right to inspect.

Try it yourself

If ILSpy already does everything you need, keep using it — it is a fine tool. But if you have caught yourself wishing the reading experience felt more like your IDE, Glass.NET gives you ILSpy-quality decompilation with a Visual-Studio-native, navigation-first UI. It is free — no license, no seats, no sign-up. Download it, open an assembly, and press F12.