dnSpy Alternative in 2026: A Maintained .NET Decompiler

If you have opened a .NET assembly in the last few years without its source, chances are you reached for dnSpy. It was the Swiss Army knife of managed reverse engineering: decompile to C#, read IL, set breakpoints, edit methods, and save the assembly back out. For a long time it was the default answer to “how do I look inside this DLL?”

The problem is that the original dnSpy is no longer maintained. The repository was archived by its author, which means no new releases, no fixes for newer .NET versions, and no security updates. It still runs, and it still works on a lot of assemblies — but “still works” is not the same as “maintained.” If you are picking a tool in 2026, it is worth knowing what dnSpy actually did for you, and which of those jobs a modern, actively developed tool can pick up.

TL;DR: dnSpy is archived. The community fork dnSpyEx carries on the debugging-and-editing role. For the far more common job of reading and understanding an assembly, a maintained decompiler like Glass.NET (free, VS-native UI), ILSpy or dotPeek is the better long-term pick. I build one of these, and I will still tell you honestly where the others win.

What people actually used dnSpy for

dnSpy was three tools in one trench coat. Most people used only one or two of them:

• Decompiling to C#. By far the most common use — open a DLL, read the reconstructed source, figure out what a method does.
• Reading IL. When the decompiled C# looked surprising, flip to the underlying IL to see what the assembly literally contains.
• Live debugging. Attach to a running process, set breakpoints in decompiled code, and step through an assembly you had no source for.
• Editing and re-saving. Patch a method’s IL or C#, save the assembly, and run the modified version.

The first two — reading C# and IL — are what the overwhelming majority of people need most of the time. And those are exactly the jobs that maintained decompilers do very well today.

Option 1: Glass.NET — a free, maintained reader

I work on Glass.NET, so take this section as informed rather than neutral — I will keep it honest. Glass is a free .NET decompiler with a Visual-Studio-native, Avalonia-based UI. It turns any managed assembly back into readable C#, and it is built for the part dnSpy users spent most of their time on: reading and navigating unfamiliar code.

• Decompile to clean C#. Glass is built on ICSharpCode.Decompiler, the same proven engine behind ILSpy, so the C# it produces stays current with modern language features.
• Navigate like it’s your own project. Go to Definition (F12), Find All References (Shift+F12), Go To All (Ctrl+T), call and type hierarchy, a namespace ▸ type ▸ member breadcrumb, and navigation history.
• C# and IL side by side. Flip any member to its IL when the C# looks surprising — the same “confirm what it actually does” move dnSpy gave you.
• Export to a buildable project when you want the code on disk to grep, diff or open in Visual Studio.
• Static analysis only. Glass reads metadata and IL and reconstructs C#; it never runs the assembly it inspects.

What Glass does not do: it is not a debugger, and it does not edit and re-save assemblies. If those are the dnSpy features you cannot live without, keep reading — an honest alternative comes below.

Glass is free forever — no license, no seats, no sign-up — and actively developed. If reading and understanding assemblies is your main job, it is the closest maintained match for how most people used dnSpy. There is a fuller walkthrough in how to decompile a .NET DLL to C#.

Option 2: ILSpy — the open-source workhorse

ILSpy is the open-source project whose decompiler engine (ICSharpCode.Decompiler, MIT-licensed) powers Glass and several other tools. It is free, actively maintained, and produces excellent C#. If you want a no-frills, trustworthy reader and you are comfortable with a leaner UI, ILSpy is a great default and has been for years. It reads C# and IL, exports projects, and keeps pace with new language features. For a side-by-side, see Glass.NET vs ILSpy, dnSpy and dotPeek.

Option 3: dotPeek — free, from JetBrains

dotPeek is JetBrains’ free decompiler. It uses JetBrains’ own decompiler engine rather than the ILSpy one, integrates with ReSharper, and can act as a symbol server so Visual Studio can step into decompiled code. If you already live in the JetBrains ecosystem, it is a natural fit and it is actively maintained. There is a dedicated dotPeek alternative write-up if you are comparing the two directly.

Option 4: dnSpyEx — when you truly need the debugger

Here is the honest part. There is one thing dnSpy did that none of the pure decompilers above replicate: live debugging and editing of a managed binary. Attaching to a process, stepping through decompiled code, patching a method and saving the assembly — that is a genuinely different job from reading one.

If that is what you need, the community has you covered: dnSpyEx is a maintained fork that carries dnSpy forward. It is the right tool when you specifically need to debug or edit a managed assembly at the IL level. I am not going to pretend a static reader replaces a debugger — it does not. Reach for dnSpyEx for that workflow, and reach for a decompiler for everything else. There is more on the no-debugger scenarios in how to debug a .NET app when you don’t have the source.

Which dnSpy alternative should you pick?

Match the tool to the job dnSpy was doing for you:

You used dnSpy to…	Reach for
Read and understand an assembly (the common case)	Glass.NET, ILSpy, or dotPeek
Navigate a large unfamiliar codebase quickly	Glass.NET
Stay inside the JetBrains ecosystem	dotPeek
Live-debug a running managed process	dnSpyEx
Edit and re-save an assembly’s IL	dnSpyEx

There is no single winner, because dnSpy was never a single tool. For the reading and navigating that most people did most of the time, a maintained decompiler is the upgrade. For the debugging and editing niche, the community fork is the answer.

A worked example: reading a method

Say a NuGet package throws an InvalidOperationException deep in a stack trace and you have no source. In a maintained decompiler the flow is the same one you knew from dnSpy: open the assembly, use Go To All to jump straight to the type the stack trace names, read the reconstructed C#, and flip to IL if the C# looks off. Within a minute you are reading something like:

public T Dequeue()
{
    if (_count == 0)
        throw new InvalidOperationException("Queue empty");
    T item = _items[_head];
    _items[_head] = default!;
    _head = (_head + 1) % _items.Length;
    _count--;
    return item;
}

Now you can see the exact precondition that fired, without ever running the code. That is the everyday dnSpy workflow, on a tool that still gets updates.

Get a maintained tool

dnSpy served the .NET community well, and dnSpyEx keeps its debugging role alive. But for the reading and navigating that most of us actually do, you deserve a tool that is still being built. Glass.NET is free — no license, no seats, no sign-up — built on the same proven engine as ILSpy, with a fast VS-native UI. Download it, open the assembly that is giving you trouble, and press F12.