icsharpcode/ILSpy

This system is a comprehensive .NET decompiler and analysis toolkit, comprising a core engine that transforms IL into readable C\# and XAML, and a cross-platform desktop application for interactive exploration. It provides extensive capabilities for inspecting assembly metadata, debugging decompilation pipelines, and visualizing type relationships, while also exposing these features via command-line tools and a reusable library for custom integrations.

45 changes.

The project undertook a major migration of the user interface from WPF to Avalonia, introducing cross-platform support, theme switching, and a modernized text view. Simultaneously, the decompiler engine was completely rewritten with a new ILAst intermediate representation, a robust type system, and extensive support for modern C\# language features.

52 changes.

The project extracted core decompilation logic into the reusable ILSpyX library and migrated the desktop interface to Avalonia, introducing a new docking system, search pane, and metadata explorer. This period also saw significant enhancements to BAML decompilation, ReadyToRun support, and extensive expansion of test coverage for the type system and debug information generation.

58 changes.

The project ported the ILSpy user interface from WPF to Avalonia, introducing cross-platform support for macOS and Linux alongside new UI controls and an omnibar. This period also focused heavily on stabilizing the new architecture through extensive headless UI testing, adding Docker support for the CLI tool, and implementing features like NuGet feed integration and process inspection.

ILSpy now includes a new "Open from NuGet feed" dialog that lets users search and open packages directly from NuGet V3 feeds. This feature introduces a dedicated NuGet feed client layer (INuGetFeedClient, NuGetFeedClient) that handles searching, version listing, and downloading packages to the global NuGet packages folder, reusing cached copies when available. It also adds a lazy-loading icon loader (INuGetIconLoader, NuGetIconLoader) that fetches and decodes package icons for the dialog, with caching and timeout protections. User preferences for the dialog, including the list of recently used feeds, the selected feed, and the pre-release toggle, are persisted via NuGetFeedSettings.

ILSpy/NuGetFeeds · high confidence

A new TestPlugin sample is included to demonstrate how to extend ILSpy using the MEF-based plugin system. It provides concrete examples for adding a custom decompiler language, registering entries in the main menu and toolbar, contributing items to the tree context menu, and creating a persistent options page with a UI. The sample also shows how to add content to the About page and interact with the smart text output, serving as a reference for plugin developers.

TestPlugin · high confidence

A new bookmarks feature allows users to pin locations in the decompiled C\# view. Bookmarks are anchored using stable semantic identifiers (metadata tokens or IL offsets) with a fallback to visible line numbers, ensuring they remain valid across refactoring or re-decompilation. The feature includes a gutter margin that displays bookmark glyphs with hover previews and a pulse animation on navigation, a dockable Bookmarks pane for managing the list (toggle, disable, delete, navigate, import, and export), and a navigator that restores the exact editor state (scroll position, folding, and layout settings) when jumping to a bookmark.

ILSpy/Bookmarks · high confidence

The ILSpy.ReadyToRun plugin now includes localized resource strings for its user interface elements, specifically adding support for 'Show GC Info' alongside existing strings for 'Disassembly Format', 'ReadyToRun', 'Show Debug Info', and 'Show Stack Unwind Info'.

ILSpy.ReadyToRun/Properties · high confidence

A new omnibar control has been added to the decompiler view, featuring a breadcrumb trail that displays the current node's path in the assembly tree and allows direct navigation. The bar also supports an inline search mode, activated by typing or pressing Ctrl+L, which provides a live suggestions dropdown for quickly finding types and members.

ILSpy/Controls/Omnibar · high confidence

The decompiler now supports stepping through the transformation pipeline in debug builds, allowing users to inspect intermediate states of the decompilation process. This is implemented via a new \Stepper\ class in the \ICSharpCode.Decompiler.DebugSteps\ namespace, which records nodes and their modifications at each step, enabling navigation and highlighting of changes within the decompiled output.

ICSharpCode.Decompiler/DebugSteps · high confidence

This change introduces the build tools and packaging templates required to distribute ILSpy on Linux and macOS. For macOS, it adds a PowerShell script to create, sign, and notarize DMG files, along with a Homebrew cask template for installation via Homebrew. For Linux, it provides control templates for Debian packages and a spec file for RPM packages, enabling native package management on these platforms.

BuildTools/packaging · high confidence

The decompiler now emits Event Tracing for Windows (ETW) events to track the duration and progress of the decompilation pipeline. This allows users to monitor performance metrics, such as type and member decompilation times, type system initialization, assembly resolution, and individual transform execution, using tools like PerfView on Windows or dotnet-trace on other platforms.

ICSharpCode.Decompiler/Instrumentation · high confidence

Users can now right-click any member (type, method, field, property, or event) in the assembly tree or decompiled code and select "Analyze" to push it directly into the analyzer pane, with the pane automatically brought to the front. The analyzer tree now renders entity signatures with syntax highlighting (bold type names) that update dynamically when the theme or language changes, and it deduplicates entries so re-analyzing the same entity refocuses the existing row rather than creating duplicates.

ILSpy/Analyzers · high confidence

The assembly and analyzer trees now use a new SharpTreeView control built on Avalonia's ListBox, replacing the previous WPF implementation. This update brings native keyboard navigation (including Shift/Ctrl range selection), drag-and-drop support for external files, and syntax-highlighted rich text for analyzer signatures. The tree also features improved focus visuals and consistent behavior across platform-specific UI elements.

ILSpy/Controls/TreeView · high confidence

The decompiler text view has been ported from WPF to AvaloniaEdit, introducing a new rendering pipeline that supports theme-aware syntax highlighting for C\# and IL. This change brings visual improvements including bracket pair highlighting, animated caret highlights on navigation, and debug-step highlighting for step-limited decompilation. The view now features a breadcrumb/search bar, inline UI elements, and a wait adorner with progress indication. Syntax highlighting definitions for C\# and Assembly (Asm) have been added to support proper colorization of code constructs, keywords, and literals. The editor respects user font settings and zoom controls, and includes a rich hover popup for documentation. This is the first phase of the Avalonia rewrite, focusing on the core decompiler text view functionality.

ILSpy/TextView · high confidence

Two Docker images are now available for ILSpyCmd (version 9.1.0.7988) to support interactive exploration and automated decompilation scenarios. The interactive image provides a bash shell with the tool pre-installed, while the automation image is configured to accept commands via the entrypoint, facilitating integration into CI/CD pipelines or scripted workflows.

ICSharpCode.ILSpyCmd/AsContainer · high confidence

The built-in analyzer library in ILSpyX has been significantly expanded with new analysis views. Users can now see which members override base members (Overrides) and which members are overridden by derived members (Overridden By) for methods, properties, and events. New views show which types implement interface members (Implemented By) and which interface members a member implements (Implements). Additionally, a new analyzer displays attributes applied to types, methods, fields, properties, and parameters (Applied To), and field access is now broken down into specific views for reads, writes, and address-taken operations.

ICSharpCode.ILSpyX/Analyzers/Builtin · high confidence

The ReflectionDisassembler now supports filtering and sorting of disassembled metadata entities. This is implemented via a new IEntityProcessor interface and a default SortByNameProcessor that orders types, methods, fields, properties, events, and custom attributes by their names. Users can now control the order in which members appear in the IL view, improving readability for large assemblies.

ICSharpCode.Decompiler/Disassembler · high confidence

The ICSpyCmd tool now embeds the specific commit hash in its assembly informational version, making it easier for users to identify the exact build they are using. Additionally, the command-line interface now supports a \--generate-diagrammer\ flag that allows users to generate Mermaid HTML diagrams from input assemblies, with configurable include/exclude patterns for specific namespaces.

ICSharpCode.ILSpyCmd/Properties · high confidence

The decompiler now includes a new pattern matching system within the \ICSharpCode.Decompiler.IL.Patterns\ namespace, introducing core components such as \AnyNode\ for matching individual instructions, \ListMatch\ for handling sequences with backtracking support, and \Match\ for capturing and storing results. This infrastructure enables the detection of complex IL structures, laying the groundwork for recognizing control flow constructs like loops and conditional statements in future updates.

ICSharpCode.Decompiler/IL/Patterns · high confidence

The ILSpyX project is introduced as a new, cross-platform core library designed to be reused for building alternate frontends. This change extracts and exposes key decompilation capabilities—including assembly list management, lazy-loaded assembly handling, package/bundle support, and performance instrumentation via ETW—into a reusable API surface, decoupling these core mechanics from the main ILSpy application logic.

ICSharpCode.ILSpyX · high confidence

ILSpy now supports Light and Dark themes, allowing users to switch the application's appearance to match their system preference or personal choice. This change introduces custom resource dictionaries for surfaces directly painted by ILSpy, such as the editor canvas, toolbar, and dock tabs, ensuring consistent visual styling across both modes. The implementation includes specific color definitions for elements like the editor background, selection highlights, and link foregrounds to maintain readability and contrast in both themes.

ILSpy · high confidence

This release adds a new PowerShell module (\ICSharpCode.Decompiler.PowerShell\) that exposes ILSpy's decompilation capabilities as cmdlets. Users can now decompile assemblies directly from the command line using \Get-Decompiler\ (which supports PDB debugging, dead code/stores removal, and language version selection), \Get-DecompiledSource\ for specific types or entire modules, \Get-DecompiledTypes\ to list type definitions, \Get-DecompiledProject\ to export full projects with progress reporting, and \Get-TargetFramework\ to inspect assembly metadata. The module also includes \Get-DecompilerVersion\ for error reporting and handles decompilation errors gracefully by reporting them as non-terminating errors rather than failing the script.

ICSharpCode.Decompiler.PowerShell · high confidence

ILSpy now supports viewing the native disassembly of ReadyToRun (R2R) binaries. This new feature adds a dedicated language handler that displays machine code alongside metadata such as GC transitions, debug info bounds, and stack unwind information. Users can control the visibility of these details and choose between Intel or AT&T assembly syntax via a new options page in the settings.

ILSpy.ReadyToRun · high confidence

A new test runner executable has been added to the project, enabling tests to be executed in an isolated environment. The runner loads the target test assembly into a collectible AssemblyLoadContext, allowing for proper cleanup and isolation between test runs. This change supports the broader effort to build self-contained test runners and ensures that test execution is more robust and reproducible across different platforms.

ICSharpCode.Decompiler.TestRunner · high confidence

The BAML decompilation logic has been extracted into a new, standalone library (ICSharpCode.BamlDecompiler) that can be used independently of the main ILSpy application. This library provides a public API (XamlDecompiler) to decompile BAML files into XAML, including support for resolving WPF assembly references via synthetic stand-ins when the actual assemblies are not present on the host machine. It also includes configuration options (BamlDecompilerSettings) to control error handling during assembly resolution.

ICSharpCode.BamlDecompiler · high confidence

Added a new TestTools directory containing standalone, file-based .NET SDK tools for validating the decompiler against real-world NuGet packages. The suite includes \nugetfuzz.cs\ to detect crashes, exceptions, and IL warnings by decompiling package assemblies, and a \--pdb\ mode to validate generated portable PDBs for correctness and consumer compatibility. It also includes \decompdiff.cs\ to compare decompiled output readability between two decompiler builds, and helper scripts (\nugetfuzz-all.ps1\, \nuget-top.ps1\) to automate catalog sweeps and corpus generation.

TestTools · high confidence

The decompiler now uses a new ILAst (Intermediate Language Abstract Syntax Tree) to represent decompiled code, replacing the previous internal structures. This change introduces a typed instruction set with explicit stack types, variable scopes, and control-flow containers (BlockContainer, TryCatch, etc.), enabling more accurate decompilation of complex patterns such as async/await, exception filters, and nullable types. The new architecture also supports better debugging via IL range tracking and improved handling of invalid or corrupt IL.

ICSharpCode.Decompiler/IL · high confidence

The BuildTools directory now includes a suite of new PowerShell scripts and configuration files to standardize the build and release process. \create-filelists.ps1\ generates explicit file lists for MSI and VSIX installers, while \package-linux.ps1\ and \package-macos.ps1\ automate the creation of Linux (deb, rpm, zip) and macOS (zip) distribution artifacts. Versioning is handled by \ghactions-install.ps1\ and \update-assemblyinfo.ps1\, which derive build numbers from git history and populate version metadata in assembly info and VSIX manifests. Code quality is enforced via a new \pre-commit\ hook and \format.ps1\ script that utilize \dotnet-format\ to ensure consistent whitespace formatting. Additionally, \bom-classify-encodings.ps1\ and \bom-strip.ps1\ provide utilities to detect and remove UTF-8 BOMs from text files, and \sort-resx.ps1\ ensures consistent ordering in resource files.

BuildTools · high confidence

The C\# decompiler view now features semantic syntax highlighting for keywords, types, and members, along with bracket-pair matching for parentheses, brackets, and braces. A new 'IL with C\#' mixed view interleaves decompiled C\# source as comments above IL instructions, and a debug steps pane allows stepping through the decompiler pipeline to inspect intermediate IL states.

ILSpy/Languages · high confidence

The Debug Metadata Explorer now provides dedicated, typed views for eight debug-only metadata tables (CustomDebugInformation, Document, ImportScope, LocalConstant, LocalScope, LocalVariable, MethodDebugInformation, and StateMachineMethod). Users can inspect detailed debug information such as embedded source, source-link JSON, compilation options, hoisted local scopes, and async/iterator state-machine mappings directly within the metadata browser, with structured sub-grids and syntax highlighting for blob contents.

ILSpy/Metadata/DebugTables · high confidence

ILSpy now includes a new HTML-based class diagrammer that generates interactive Mermaid diagrams from input assemblies. This feature replaces the previous WPF-based implementation, providing a modern, browser-rendered interface for visualizing type relationships. Users can now explore class hierarchies, filter types, adjust layout directions, and export diagrams as SVG, PNG, or Mermaid syntax directly within the application.

ICSharpCode.ILSpyX/MermaidDiagrammer/html · high confidence

A new Mermaid-based HTML diagrammer has been added to ILSpy, allowing users to generate interactive class diagrams from .NET assemblies. This feature extracts type metadata, inheritance, and relationships, then produces a standalone HTML file (or JSON model) that renders the diagram using the Mermaid library. It supports filtering types via include/exclude patterns, displays XML documentation comments when available, and handles complex scenarios like generic types, interfaces, and inherited members.

ICSharpCode.ILSpyX/MermaidDiagrammer · high confidence

This change introduces a dedicated Metadata Explorer feature within ILSpy, adding a new 'Metadata' folder in the assembly tree that exposes PE headers (DOS, COFF, Optional, Data Directories) and debug directories (including CodeView and PDB checksums) as browsable tree nodes and data grid tabs. It also adds a schema-driven flag filter system for metadata tables, allowing users to filter rows based on mutually exclusive groups (like TypeAttributes visibility) and independent bits, with the filter state persisting across sessions.

ILSpy/Metadata · high confidence

The ILSpyX project introduces a new PDB provider module that adds support for reading debug information from Portable PDBs and legacy PDBs. This includes utilities for locating and opening PDB files, a provider for Mono.Cecil-based legacy PDBs, and a provider for Microsoft's Portable PDB format, enabling ILSpyX to display sequence points, variables, and other debug details from these symbol files.

ICSharpCode.ILSpyX/PdbProvider · high confidence

The project decompiler now supports exporting projects in the modern SDK-style format (via \ProjectFileWriterSdkStyle\), which automatically handles implicit framework references (such as WPF/Windows Forms dependencies) and uses concise project definitions, while retaining the legacy format (\ProjectFileWriterDefault\) for older toolchains. The \IProjectFileWriter\ interface and its implementations have been made public to allow external consumers to integrate or customize project generation, and the \TargetServices\ class is now publicly accessible for target framework detection.

ICSharpCode.Decompiler/CSharp/ProjectDecompiler · high confidence

This update introduces several new UI components in the ILSpy Controls library. It adds a schema-driven filter popup (FlagsFilterPopup) with mutex chips, independent flag pills, arrow-key navigation, and a live summary line for filtering metadata columns. It also introduces a grayscale-aware image control that automatically desaturates toolbar icons when disabled, and a classic Windows-explorer style tree-line renderer for the assembly tree. Additionally, new inline DataGrid views (ResourceStringTable and ResourceObjectTable) are provided to display .resources file contents as string and object tables respectively.

ILSpy/Controls · high confidence

The new ILSpy.AddIn.VS2022 package adds context menu commands to Visual Studio 2022, allowing users to open project outputs, assembly references, NuGet packages, and specific code symbols directly in ILSpy. The add-in uses Roslyn to resolve symbols and paths, supporting .NET Framework, .NET Core, and .NET Standard assemblies, and includes logic to prompt users to build the solution if a project output is missing.

ILSpy.AddIn.VS2022 · high confidence

The ILSpyX Abstractions layer now exposes a set of new interfaces and utilities that decouple core decompiler logic from the host application. ILLanguage defines the contract for generating language-specific source code and metadata mappings. IResourceFileHandler and IResourceNodeFactory provide a plugin-based system for exporting embedded resources to project files and creating custom tree nodes for resource entries. ITreeNode and ITreeNodeFactory establish the generic interface for the navigation tree structure. Additionally, the new GuessFileType utility enables the application to automatically detect whether a file is Binary, Text, or XML based on byte-order marks and content analysis.

ICSharpCode.ILSpyX/Abstractions · high confidence

This change introduces several new view models in the ILSpy/ViewModels directory that enable new user-facing capabilities. The CompareTabPageModel adds a new tab for viewing a structural metadata diff between two assemblies, allowing users to see what changed between versions with an option to hide identical rows. The MetadataTablePageModel provides a new tab content type for displaying metadata tables with advanced filtering (regex, flags, numeric comparisons) and row details. Additionally, the OpenFromNuGetFeedDialogViewModel and OpenFromProcessDialogViewModel introduce new dialogs for browsing and opening packages from NuGet feeds and inspecting assemblies from running .NET processes, respectively. These view models also support the new docking and tab infrastructure (ContentPageModel, ContentTabPage) that underpins these features.

ILSpy/ViewModels · high confidence

ILSpy now includes a built-in mechanism to automatically check for new stable releases. The system polls an XML feed hosted at icsharpcode.github.io/ILSpy/updates.xml to determine if a newer version is available. Users can enable or disable automatic checks via settings, and when enabled, the application will only perform a check once every 7 days to avoid excessive network traffic. A manual check is also available through the Help menu. The update service respects user proxy settings and includes safeguards against path traversal in download URLs.

ILSpy/Updates · high confidence

The decompiler now includes a new FlowAnalysis module that introduces a generic DataFlowVisitor framework, definite assignment analysis, and reaching definitions analysis. This infrastructure enables more accurate decompilation by correctly handling try-finally blocks, out-parameters, and uninitialized variable usage, while also supporting advanced control flow features like loop detection and dominance tree computation.

ICSharpCode.Decompiler/FlowAnalysis · high confidence

The documentation folder now includes several new reference files to help users and contributors understand and operate ILSpy. A new HTML document details the decompiler architecture, explaining the ILAst pipeline, transforms, and design goals. A text file documents available command-line arguments, including options for navigation, search, and response files. A Markdown guide explains how to collect performance traces using dotnet-trace and PerfView, specifying the EventSource providers and keyword masks. Additional files cover technical specifics such as ILAst pattern matching, the ImageListStreamer on-disk format, IntPtr conversion behaviors, and a custom ResourcesFile implementation.

doc · high confidence

This change introduces a new metadata layer in the Decompiler, including the \MetadataFile\ abstraction, \IAssemblyResolver\ interface, and \UniversalAssemblyResolver\ to handle assembly loading and resolution. It adds \DotNetCorePathFinder\ to locate .NET Core and .NET Standard assemblies via NuGet packages and runtime packs, and \DotNetCorePathFinderExtensions\ to detect target framework IDs from metadata or file paths. The update also includes new types for code mapping (\CodeMappingInfo\), type decoding (\FindTypeDecoder\, \FullTypeNameSignatureDecoder\), and exported types (\ExportedTypeMetadata\), along with exception classes for better error reporting during assembly resolution.

ICSharpCode.Decompiler/Metadata · high confidence

A new Search pane has been added to ILSpy, providing a dedicated UI for finding types, members, and constants across loaded assemblies. The pane features a search input with a DSL for filtering (e.g., t: for types, m: for members, /regex/ for regular expressions, and inassembly:/innamespace: for scoping), a mode picker, and a sortable results grid. Search results are streamed in real-time with a 1000-result cap and a progress indicator. The implementation uses an Avalonia-based view, a view-model that debounces typing and settles assembly list changes, and a background orchestrator that walks assemblies serially to maintain UI responsiveness. Context menu entries allow users to scope searches to specific assemblies or namespaces directly from the tree view.

ILSpy/Search · high confidence

The decompiler's type system now supports C\# 12 inline array expressions and C\# 14 first-class span types, default literals, and throw expressions. This is implemented by adding new resolve result classes (such as \DefaultLiteralResolveResult\ and \ByReferenceResolveResult\ with \ReferenceKind\) and extending the \Conversion\ class with specific conversion types for inline arrays, spans, and default literals, enabling accurate semantic analysis and decompilation of code using these modern C\# features.

ICSharpCode.Decompiler/Semantics · high confidence

The decompiler now includes two new Roslyn source generators: DecompilerSyntaxTreeGenerator and DecompilerSettingsGenerator. The syntax tree generator automates the creation of the Abstract Syntax Tree (AST) nodes, handling child slot management, constructor generation, and pattern-matching logic (DoMatch) based on declarative attributes, while enforcing strict type safety for child slots. The settings generator produces boilerplate for decompiler configuration options, automatically managing backing fields, change notifications, and version-gating logic tied to specific C\# language versions. These changes reduce manual code maintenance and ensure consistency in the decompiler's internal syntax tree and settings structures.

ICSharpCode.Decompiler.Generators · high confidence

The Themes area introduces several new behaviors for the document tab strip: a multi-row layout toggle activated by the mouse wheel, an overflow dropdown for switching documents when tabs don't fit, and a 'freeze' feature for preview tabs (replacing the previous 'pin' concept) with an inline button and context menu entry. It also adds the core infrastructure for theme-aware syntax highlighting, including a \ThemeManager\ that switches between Light and Dark variants, a \SyntaxColor\ model, and a hand-authored dark palette for C\# keywords and types to ensure proper contrast.

ILSpy/Themes · high confidence

ILSpy now exposes the raw rows of many ECMA-335 metadata tables (such as Assembly, AssemblyRef, Field, Event, CustomAttribute, and Constant) as dedicated tree nodes. This allows users to inspect low-level metadata details—including tokens, heap offsets, and attribute flags—that are not visible in the standard decompiled view.

ILSpy/Metadata/CorTables · high confidence

The decompiler engine now detects and extracts assemblies from .NET 5+ single-file bundles. This is achieved by adding a new \SingleFileBundle\ class that parses the bundle manifest header and entries, allowing the decompiler to locate and process the embedded IL assemblies within a self-contained executable.

ICSharpCode.Decompiler · high confidence

The decompiler can now read and expose the \!AvaloniaResources\ manifest resource used by the Avalonia UI framework. A new \AvaloniaResourcesFile\ utility parses the binary index and data sections, allowing users to view individual compiled XAML, images, and other assets embedded in Avalonia assemblies as a list of path-to-byte mappings.

ICSharpCode.Decompiler/Util · high confidence

ILSpy can now inspect and open assemblies from running .NET processes. This adds a new process-exploration layer that discovers CoreCLR processes via the standard diagnostics IPC endpoint (working on Windows, Linux, and macOS) and .NET Framework processes on Windows via OS-level module scanning. It implements the necessary IPC protocol, platform-specific port scanning, and nettrace rundown parsing to retrieve the list of loaded managed modules, providing the backend capability for the "Open from running process" feature.

ILSpy/Processes · high confidence

The command-line tool now supports decompiling WPF BAML resources into XAML files (automatically when using the -p project generation flag, or via --resource for single files), allowing users to inspect and rebuild WPF applications. A new --dump-table mode lets users export raw metadata tables (e.g., TypeDef, MethodDef) as aligned console text or JSON for low-level analysis. Debug builds now include an --ilast option to dump the decompiler's intermediate ILAst representation, with --after-transform to inspect the output at specific pipeline stages. Additionally, users can now list and extract embedded resources with --list-resources and --resource, and generate interactive HTML type diagrams with --generate-diagrammer.

ICSharpCode.ILSpyCmd · high confidence

The BAML reader in the decompiler is now hardened against malformed or crafted BAML files that previously caused uncatchable StackOverflowExceptions or out-of-bounds crashes. The new \BamlDeferReader\ implementation bounds all list accesses and caps the nesting depth of defer blocks (e.g., static resources, key elements) to 1000 levels, ensuring that any such malicious input fails with a catchable \InvalidDataException\ instead of crashing the application.

ICSharpCode.BamlDecompiler/Baml · high confidence

The LightJson parser in the Decompiler now enforces a maximum nesting depth of 64 levels when reading JSON. Previously, deeply nested structures (such as crafted .deps.json files) could cause an uncatchable StackOverflowException; the parser now throws a JsonParseException with the error type MaximumNestingDepthExceeded instead, ensuring stable parsing of malformed or malicious input.

ICSharpCode.Decompiler/Metadata/LightJson · high confidence

The BAML decompiler project now includes an AssemblyInfo.cs file that embeds the MIT license header, sets COM visibility to false, and configures assembly versioning to dynamically use the DecompilerVersionInfo constants for both AssemblyVersion and AssemblyInformationalVersion.

ICSharpCode.BamlDecompiler/Properties · high confidence

Added an Info.plist file that defines the metadata and structure for the macOS application bundle, including the bundle identifier, executable name, minimum system version (macOS 11.0), and high-resolution display support. This file is required for packaging ILSpy as a native macOS application.

ILSpy/Assets/macos · high confidence

The non-UI analyzer code has been relocated to the ILSpyX/Analyzers directory, introducing new core components such as AnalyzerContext, AnalyzerScope, and the IAnalyzer interface to manage analysis logic and scope resolution. To improve performance and reduce dependencies, the heavy System.ComponentModel.Composition library has been replaced with the lightweight System.Composition.AttributedModel, allowing analyzers annotated with ExportAnalyzerAttribute to be collected without requiring MEF. This change also includes added nullability annotations and refactored pattern matching to avoid multiple enumerations, resulting in a more efficient and maintainable analyzer framework.

ICSharpCode.ILSpyX/Analyzers · high confidence

The ILSpyX assembly metadata has been updated to include the Git commit hash in the informational version string, making it easier for users to identify the exact build version. Additionally, the assembly version is now dynamically generated from the DecompilerVersionInfo constants rather than being hardcoded.

ICSharpCode.ILSpyX/Properties · high confidence

The assembly tree view in ILSpy has been ported to the Avalonia UI framework, introducing new tree node classes for managing assemblies, references, and embedded resources. AssemblyTreeNode now supports lazy loading with visual indicators for loading and failure states, and handles drag-and-drop reordering. AssemblyReferenceTreeNode displays resolved and unresolved references, including transitive dependencies, and provides detailed load error logs. New nodes like AssemblyReferenceReferencedTypesTreeNode expose TypeRef and ExportedType entries for each reference. Resource handling has been enhanced with dedicated nodes for Avalonia resources (AvaloniaResourcesFileTreeNode) and BAML files (BamlResourceEntryNode), allowing users to view and decompile embedded XAML. The tree also supports comparing assemblies via ComparisonEntryTreeNode, which highlights differences with color-coded backgrounds.

ILSpy/TreeNodes · high confidence

The Assembly tree pane now uses the SharpTreeView control, enabling users to drag-reorder top-level assemblies in the list and providing a refined context-menu experience that highlights the target row without changing the active selection. The tree also supports multi-selection, keyboard navigation, and visual cues for auto-loaded and non-public API nodes.

ILSpy/AssemblyTree · high confidence

The ILSpy user interface has been ported from WPF to Avalonia, introducing new view implementations for the main application components. This includes a new CompareView that renders assembly diffs in a hierarchical DataGrid with a 'Show identical entries' toggle, a ContentTabPageView that hosts swappable inner content (decompiler, metadata, options) in a single ContentControl to preserve scroll and folding state during tab switches, and a DebugSteps pane for visualizing the C\# AST pipeline. The port also brings a new MainToolBar with flat, grayscale-aware button styles, a MainMenu that integrates with the macOS system menu bar, and dialogs for managing assembly lists and exporting projects/solutions.

ILSpy/Views · high confidence

The BAML decompiler in the Xaml folder has been rewritten to produce XAML output that is valid and can be read back by a standard XAML parser. This change introduces new internal classes (NamespaceMap, XamlExtension, XamlProperty, XamlResourceKey, XamlType, XamlUtils) to correctly handle XML namespace resolution, markup extension formatting, property resolution, and escaping of characters that XML cannot represent, ensuring the decompiled output is round-trippable.

ICSharpCode.BamlDecompiler/Xaml · high confidence

The C\# syntax tree in ICSharpCode.Decompiler/CSharp/Syntax has been completely rewritten to use a slot-based child model (CSharpSlotInfo) instead of the previous role/linked-list hierarchy, enabling typed child accessors and incremental index maintenance. Comments and preprocessor directives are now stored as leading/trailing trivia on nodes rather than as child nodes, and the entire syntax layer has been enabled for C\# nullable reference types to improve type safety. These changes alter the internal structure and traversal of the decompiled AST, which may affect custom visitors or code that relied on the old child-access patterns.

ICSharpCode.Decompiler/CSharp/Syntax · high confidence

The C\# syntax tree in ICSharpCode.Decompiler/CSharp/Syntax/Expressions has been rewritten to use C\# nullable reference types (\#nullable enable) and a new \[Slot\]-based API for accessing child nodes, replacing the previous Role/NodeType hierarchy. This change improves null-safety and provides a more structured, grammar-aligned way to navigate and modify the decompiled C\# code structure, which may affect how consumers of the AST interact with expression nodes.

ICSharpCode.Decompiler/CSharp/Syntax/Expressions · high confidence

The application now uses a unified settings system in ILSpyX that consolidates configuration management, including a new MutexProtector to prevent data corruption when multiple instances edit the settings file simultaneously. It also introduces a fix for corrupted configuration files (issue \#2919) by preserving unreadable XML files instead of overwriting them, and replaces the previous path provider with a configurable Func\<string\> for greater flexibility in locating the settings file.

ICSharpCode.ILSpyX/Settings · high confidence

The BAML decompiler now includes a comprehensive set of new handlers in the Records directory to support a wider variety of BAML record types, improving the fidelity of the generated XAML. These additions include handlers for assembly and attribute metadata, connection IDs, constructor parameter types, and literal content. Crucially, the update introduces robust support for static resources (including optimized static resources and resource keys) and complex property values via extensions and custom serializers (such as brushes, paths, and collections). This ensures that decompiled XAML is more likely to be valid and readable by standard XAML parsers.

ICSharpCode.BamlDecompiler/Handlers/Records · high confidence

The internal IL Abstract Syntax Tree (ILAst) has been significantly restructured to use a strongly-typed, specialized instruction model. The evaluation stack has been removed from the ILAst in favor of direct stack variable introduction, and the previous generic instruction representations have been replaced by specific classes such as BinaryNumericInstruction, CallInstruction, Block, and BlockContainer. This change introduces precise type information (StackType) for inputs and outputs, supports lifted nullable operations, and enforces strict invariants to improve decompilation accuracy and transform reliability.

ICSharpCode.Decompiler/IL/Instructions · high confidence

The ILSpy application now includes its assembly metadata and user-interface resource strings again. The \AssemblyInfo.cs\ file has been added back to ensure the DLL is built with the correct version information (derived from \DecompilerVersionInfo\) and standard assembly attributes, while the \Resources.resx\ and \Resources.Designer.cs\ files provide the strongly-typed, localized strings for the UI. This change ensures that versioning is accurate and that the application's interface text is properly managed and translatable.

ILSpy/Properties · high confidence

The ILSpy/Commands folder now contains a comprehensive set of new command implementations that replace the previous ad-hoc or singleton-based approach. This includes a centralized CommandManager to handle UI state re-querying (mimicking WPF's CommandManager), and a suite of context-menu and main-menu commands for core features such as comparing assemblies, creating diagrams, exporting projects/solutions, extracting package entries, and navigating decompiled code. The About command has been refactored to support a reusable welcome page and inline update controls, while navigation commands (Browse Back/Forward) are now explicitly wired through the DockWorkspace. This change consolidates command logic, improves testability, and standardizes how user actions are exposed in the UI.

ILSpy/Commands · high confidence

The solution file writer now correctly handles SDK-style project references, including proper XML namespace handling and inter-project reference fixes. It also stores the project type GUID in the .sln file and properly handles directories with '.' in their names when calculating relative paths.

ICSharpCode.Decompiler/Solution · high confidence

The BAML decompiler now produces more accurate and usable XAML output by recovering the application's StartupUri from generated code, correctly emitting x:FieldModifier attributes for public fields, escaping invalid XML characters in string values, and ensuring that only properties with setters are converted to XAML attributes.

ICSharpCode.BamlDecompiler/Rewrite · high confidence

The PDB generation logic in the DebugInfo namespace has been enhanced to better match original assembly debug information. It now supports reading and emitting tuple element names and dynamic type information, and correctly handles async methods by writing state-machine hoisted local scopes and method stepping information. The generator also introduces import scope tables to accurately reflect namespace usings and improves sequence point handling for LINQ expressions, expression-bodied members, and constructor initializers.

ICSharpCode.Decompiler/DebugInfo · high confidence

The decompiler now correctly handles local functions, including those that are recursive, generic, or mutually recursive, as well as lambdas with multiple return statements. This ensures that local functions are no longer incorrectly decompiled as regular methods or hidden behind display classes, and that lambda expressions are properly reconstructed from their underlying IL patterns.

ICSharpCode.Decompiler/IL/Transforms · high confidence

The documentation system now automatically resolves XML documentation from the .NET reference pack for modern runtimes (e.g., .NET 5+), ensuring tooltips and hover information remain available even when assemblies lack side-by-side .xml files. Additionally, the ID string matching logic has been refined to better handle hand-written documentation identifiers by trying multiple dialects (including MSVC C++/CLI) and loosening matches for generic arities and parameter lists, which reduces missing documentation for overloads and complex signatures.

ICSharpCode.Decompiler/Documentation · high confidence

The ILSpy installer now displays a verification dialog showing the target installation directory before the installation process begins, allowing users to confirm the location. This change is implemented in the ILSpy.Installer project by configuring the WiX UI sequence to navigate from the welcome screen to the verification screen and updating the localization strings to display the selected path.

ILSpy.Installer · high confidence

The tree view component now includes a new set of platform abstraction interfaces (IPlatformDataObject, IPlatformDragDrop, IPlatformDragEventArgs, IPlatformRoutedEventArgs, ITreeNodeImagesProvider) and the XPlatDragDropEffects enum within the PlatformAbstractions namespace. These interfaces define the contract for cross-platform drag-and-drop functionality, providing the necessary infrastructure to support the fix for drag-and-drop issues in the Assemblies tree view by decoupling the drag-and-drop logic from platform-specific implementations.

ICSharpCode.ILSpyX/TreeView/PlatformAbstractions · high confidence

The C\# decompilation pipeline in ICSharpCode.Decompiler has been significantly refactored and expanded. The \DeclareVariables\ transform has been rewritten to improve variable scoping and collision resolution. New transforms have been introduced, including \AddCheckedBlocks\ for handling overflow checks, \AddXmlDocumentationTransform\ for preserving XML comments, and \FlattenSwitchBlocks\ for simplifying switch statements. Existing logic for combining query expressions (\CombineQueryExpressions\) and fixing name collisions (\FixNameCollisions\) has been updated. Additionally, utilities for escaping invalid identifiers and removing compiler-generated assembly attributes have been added to ensure the decompiled code is valid and compilable.

ICSharpCode.Decompiler/CSharp/Transforms · high confidence

The C\# decompiler in ICSharpCode.Decompiler/CSharp has been significantly restructured to improve accuracy and support modern C\# features. The internal IL representation (ILAst) was redesigned, including the removal of the evaluation stack in favor of direct stack variables, and the introduction of new instruction types (e.g., SwitchInstruction, CompoundAssignmentInstruction). The type system was migrated to use the Semantic Reference Model (SRM), replacing the legacy NRefactory-based system, which enables better handling of generic contexts and overload resolution. These changes underpin support for numerous C\# language versions (up to C\# 14), including records, pattern matching, nullable reference types, local functions, and async/await state machines. Additionally, the decompilation pipeline now includes new transforms for control flow simplification, variable inlining, and named arguments, while removing obsolete ones.

ICSharpCode.Decompiler/CSharp · high confidence

A new \ICSharpCode.ILSpy.AppEnv\ namespace has been introduced to house core application environment code, including configuration, runtime, and error handling. This change centralizes MEF composition via \AppComposition\ (handling plugin discovery and export resolution), implements a categorized, opt-in diagnostic logging system (\AppLog\) with startup timing, and introduces a non-fatal assertion handling mechanism (\ILSpyTraceListener\ and \AssertionFailedDialog\) that prevents the process from crashing on \Debug.Assert\ failures during decompilation. Additionally, it standardizes single-instance coordination (\SingleInstance\) using cross-platform named mutexes and pipes, and provides a global exception handler (\GlobalExceptionHandler\) to surface unhandled errors to the user.

ILSpy/AppEnv · high confidence

The C\# Resolver subsystem has been replaced with a new, comprehensive implementation located in the ICSharpCode.Decompiler/CSharp/Resolver directory. This change introduces a complete rewrite of the type resolution and overload resolution logic, including new core components such as CSharpConversions, CSharpOperators, CSharpResolver, MemberLookup, NameLookupMode, OverloadResolution, and TypeInference. The new resolver implements C\# specification draft-v11 standards for implicit conversions, operator lifting, member lookup accessibility, and type inference algorithms (including an improved algorithm for fixing type bounds). It also adds support for modern C\# features such as tuples, nullable reference types, and improved overload resolution tie-breaking rules, significantly enhancing the accuracy of decompiled code by aligning with current C\# language semantics.

ICSharpCode.Decompiler/CSharp/Resolver · high confidence

The Options dialog has been replaced with a new tabbed interface (Decompiler, Display, Misc) where changes apply immediately without an Apply button. The Display panel now includes a theme picker, font size editing in points with a live preview, and controls for word wrap, brace highlighting, and metadata tokens. The Decompiler panel uses reflection to automatically surface all decompiler settings grouped by category, including a tri-state checkbox to bulk-toggle settings within a group. A new Misc panel allows users to enable multiple application instances and control whether previously open assemblies are loaded on startup.

ILSpy/Options · high confidence

The decompiler now organizes key control flow transforms into a dedicated \ICSharpCode.Decompiler.IL.ControlFlow\ namespace. This includes new or refactored components for decompiling C\# 5+ async/await state machines (\AsyncAwaitDecompiler\), handling \await\ expressions inside \catch\ and \finally\ blocks (\AwaitInCatchTransform\, \AwaitInFinallyTransform\), detecting and simplifying \if\ structures (\ConditionDetection\), and identifying \fixed\ statement pinned regions (\DetectPinnedRegions\). These changes improve the accuracy of decompiling complex control flow patterns such as nested exception handlers, async streams, and unsafe pointer operations.

ICSharpCode.Decompiler/IL/ControlFlow · high confidence

The application now uses a new docking framework (Dock.Avalonia) to manage windows and tabs, replacing the previous layout engine. This introduces browser-style Back/Forward navigation for document tabs, allowing users to traverse their viewing history. The system supports multiple document tabs, including a preview tab that can be 'frozen' (previously 'pinned') to keep content while browsing other nodes. Layouts are now persisted to a JSON sidecar file (ILSpy.Layout.json) alongside the existing XML settings. Tool panes and document tabs are managed via a centralized registry, and the UI now includes a Window menu listing open tabs and commands to close all tabs or all but the current one.

ILSpy/Docking · high confidence

The file loading subsystem has been refactored to use a new \IFileLoader\ interface and a \FileLoaderRegistry\ that manages a prioritized chain of loaders. This change introduces dedicated loaders for specific formats—including \ArchiveFileLoader\ (ZIP), \BundleFileLoader\, \PEFileLoader\, \MetadataFileLoader\, \WebCilFileLoader\ (WebAssembly), and \XamarinCompressedFileLoader\ (XALZ)—replacing the previous monolithic loading logic. Users benefit from more robust handling of nested bundles (preventing recursive loading loops) and improved security against crafted XALZ headers, which are now validated against decompression bombs and truncated input.

ICSharpCode.ILSpyX/FileLoaders · high confidence

The Type System implementation layer in ICSharpCode.Decompiler/TypeSystem/Implementation has been populated with foundational classes that define the runtime behavior of the decompiler's type model. This includes AbstractFreezable for managing immutable, thread-safe state; AbstractType and DecoratedType to handle type hierarchies and nullability annotations; and DefaultParameter/DefaultTypeParameter to represent method parameters and generic constraints with support for reference kinds (ref, out, in, ref readonly). Attribute handling is now driven by AttributeListBuilder and CustomAttribute, which decode metadata blobs and handle errors gracefully, while helper classes like BaseTypeCollector and CSharpTypeResolveContext manage inheritance resolution and compilation context. These changes establish the concrete infrastructure for resolving types, attributes, and parameters from metadata.

ICSharpCode.Decompiler/TypeSystem/Implementation · high confidence

This location introduces several foundational utilities that support the broader application refactor. ShellHelper consolidates OS shell launches (opening folders, revealing files, opening with default apps) into a single cross-platform entry point, using shell COM on Windows to reveal multiple files in a single Explorer window. ImageListDecoder provides a cross-platform, UI-framework-free decoder for System.Windows.Forms.ImageListStreamer payloads, enabling image handling without WPF dependencies. MessageBus and WeakEventSource implement a type-keyed, weak-reference pub-sub system to decouple components and prevent memory leaks without requiring explicit unsubscription. Additionally, a DEBUG-only GraphVizGraph emitter allows the Control Flow Graph viewer to dump DOT language and render it via the system 'dot' tool.

ILSpy/Util · high confidence

The decompiler output system has been refactored to support advanced UI features. A new \IAmbience\ interface and \ConversionFlags\ enum allow fine-grained control over symbol conversion, enabling C\# semantic highlighting for identifiers, properties, and events, as well as support for modern C\# features like record structs, unsigned right shift, and \private protected\. The \ITextOutput\ interface now includes \INodeTrackingOutput\ capabilities, which record the character ranges of rendered nodes to enable interactive features like highlighting and scrolling to changed instructions in the IL view. Additionally, \TextTokenWriter\ has been updated to use these new APIs for generating navigable hyperlinks and hover-only tooltips for dynamic members and local variables.

ICSharpCode.Decompiler/Output · high confidence

The pattern matching system in the C\# decompiler has been restructured to operate on list-indexed slot children rather than the previous AST structure. This change introduces a new \INode\ interface and a collection-based matching algorithm (\DoMatchCollection\) that walks child lists by index, supporting backtracking for non-deterministic patterns like \Repeat\ and \OptionalNode\. The update also replaces legacy AST null-objects with nullable reference types and generates typed \Slots\ to key 1:1-kind child access, improving the robustness and clarity of pattern definitions.

ICSharpCode.Decompiler/CSharp/Syntax/PatternMatching · high confidence

The C\# decompiler's syntax tree has been rewritten to use a source-generated, slot-based AST model. This change introduces new AST node classes (such as Attribute, NamespaceDeclaration, and TypeDeclaration) that use \[Slot\] attributes for structured child access and moves comments and preprocessor directives into a new Trivia system attached to nodes rather than occupying child slots. The update also adds support for modern C\# features, including file-scoped namespaces, C\# 9 record classes, and C\# 10 record structs, while enabling nullable reference types across the syntax layer.

ICSharpCode.Decompiler/CSharp/Syntax/GeneralScope · high confidence

The C\# decompiler's AST nodes for type members (such as Accessor, ConstructorDeclaration, MethodDeclaration, PropertyDeclaration, and others) have been rewritten to replace the previous linked-list child storage with a typed, slot-based architecture. This change introduces the \[Slot\] attribute to define child nodes, enables nullable reference types across these files, and updates the API to use nullable types for optional children (e.g., BlockStatement? Body). The refactoring also adds support for newer C\# features like init accessors (via AccessorKind.Init and IsInitOnly), expression bodies for indexers and properties, and scoped parameter modifiers (IsScopedRef), ensuring the decompiler can accurately model and output these language constructs.

ICSharpCode.Decompiler/CSharp/Syntax/TypeMembers · high confidence

The C\# decompiler's output pipeline has been restructured to improve reliability and formatting control. A new \ErrorTolerantOutputVisitor\ ensures that if a specific member fails to decompile, the error is captured and the rest of the file is still written, preventing truncated output. The \CSharpAmbience\ class now uses the \IAmbience\ interface to convert type system symbols, allowing for more flexible symbol-to-text conversion. Formatting is now driven by \CSharpFormattingOptions\, which provides granular control over indentation, brace styles, and property formatting. Additionally, \GenericGrammarAmbiguityVisitor\ resolves syntax ambiguities in generic expressions, and \InsertParenthesesVisitor\ ensures correct operator precedence in the generated code.

ICSharpCode.Decompiler/CSharp/OutputVisitor · high confidence

The statement-level AST nodes in the C\# decompiler have been rewritten to use a new slot-based architecture, replacing the previous role hierarchy with explicit \[Slot\] attributes and nullable reference types. This change improves type safety and clarity for developers working with the syntax tree, as child nodes are now accessed via strongly-typed, nullable properties (e.g., \Condition\ in \ForStatement\ or \EmbeddedStatement\ in \WhileStatement\) rather than generic collections or role-based lookups. The refactoring also introduces support for C\# 8.0 features like \await foreach\ and \await using\ by adding \IsAsync\ flags to \ForeachStatement\ and \UsingStatement\, and models local functions via \LocalFunctionDeclarationStatement\. Users will see more precise and safer APIs when traversing or modifying statement structures, with nullability explicitly enforced by the compiler.

ICSharpCode.Decompiler/CSharp/Syntax/Statements · high confidence

The project now enforces a unified coding style and formatting baseline via a new .editorconfig file, which standardizes indentation, line endings, and C\# language conventions (such as naming rules and expression-bodied members) across the codebase. To support this and improve build ergonomics, the repository introduces solution filters (ILSpy.Desktop.slnf, ILSpy.XPlat.slnf) that allow developers to open and build specific subsets of the solution (e.g., just the UI or just the decompiler engine) without loading the entire workspace. Additionally, a new Directory.Build.props file centralizes build settings like treating warnings as errors and enabling package lock files, while .gitattributes and .gitignore are updated to handle line endings and generated files consistently.

(repo-wide) · high confidence

The search engine has been relocated to the ILSpyX project, introducing several behavioral improvements. Users can now include private and compiler-generated entities (such as state-machines and display classes) by typing angle brackets (\< or \>) in their search query. The 'inassembly:' filter has been expanded to match against the assembly's filename in addition to its full name, and both 'inassembly:' and 'innamespace:' filters are now case-insensitive. Additionally, literal searches for numeric values now correctly resolve to the accessor owner when dealing with properties, and the system will fall back to a general string search if the search term cannot be parsed as a single literal token.

ICSharpCode.ILSpyX/Search · high confidence

The tree view implementation in ICSharpCode.ILSpyX.TreeView has been restructured to improve performance and stability. A new flat-list data structure (FlatListTreeNode) allows efficient access to nodes by visible index, while the TreeFlattener now raises atomic ranged collection-change events to prevent index-out-of-range errors during structural mutations. Additionally, a thread-affinity system (TreeThreadAffinity) ensures that tree modifications occur only on the owning UI thread, with debug checks to catch cross-thread violations early.

ICSharpCode.ILSpyX/TreeView · high confidence

The TypeSystem location has been significantly refactored to support modern C\# language features and improve metadata handling. This includes adding support for C\# 12 'ref readonly' parameters, C\# 11 scoped parameters, C\# 10 record structs, C\# 9 init accessors, and C\# 14 first-class span types. The type system now properly handles nullability annotations, native integers (nint/nuint), function pointers, and tuple types. Additionally, the accessibility model has been updated to support 'private protected' and 'protected internal' modifiers, and extension method detection has been improved with support for both V1 and V2 encoding schemes.

ICSharpCode.Decompiler/TypeSystem · high confidence

The decompiler now includes a local copy of the essential Humanizer inflection classes (StringHumanizeExtensions, Vocabularies, and Vocabulary) to handle string singularization and pluralization, eliminating the runtime dependency on the external Humanizr/Humanizer library. This change ensures that string humanization features remain available and stable without requiring the third-party package, while retaining the original MIT license and core functionality for converting words between singular and plural forms.

ICSharpCode.Decompiler/Humanizer · high confidence

The decompiler's assembly versioning has been updated to include the source commit hash in the informational version string. This allows users to identify the exact build version more easily, which is particularly helpful when reporting issues or verifying the codebase state.

ICSharpCode.Decompiler/Properties · high confidence

Add manual resource-view test fixtures and generation tool; Added 'Ugly' test suite for decompiler edge cases; Added BAML decompiler security hardening tests; Added BAML decompiler test cases for Windows; Added BAML decompiler test suite; Added ILPretty test cases for decompiler edge cases and specific IL patterns; Added Windows-specific tests for GAC enumeration and reserved filename sanitization; Added comprehensive semantics tests for conversions, overload resolution, and type inference; Added comprehensive test coverage for the Bookmarks feature; Added comprehensive test coverage for the assembly list and tree interactions; Added headless UI tests for the Docking subsystem; Added headless tests for assembly tree input gestures; Added pretty-printed test cases for async/await patterns; Added regression tests for type system edge cases; Added test coverage for ilspycmd CLI features; Added test coverage for project decompiler export logic; Added tests for .NET Framework process discovery; Added tests for AST node collection enumeration and trivia handling; Added tests for C\# and IL ambience, AST location tracking, and output reference handling; Added tests for DecompilerEventSource instrumentation; Added tests for ILSpy analyzer library components; Added tests for ILSpy command-line, save, and navigation behaviors; Added tests for ILSpyX EventSource instrumentation; Added tests for MEF composition, error reporting, and configuration file paths; Added tests for MessageBus and ShellHelper utilities; Added tests for NuGet feed integration, Debug Steps pane, and UI components; Added tests for Options dialog behavior and settings persistence; Added tests for TextView decompiler settings bridging, keyword references, and output limits; Added tests for assembly tree model, navigation, and startup behavior; Added tests for browser-style navigation history and view-state restoration; Added tests for diagnostics, input tracing, and startup performance; Added tests for language-specific decompiler features and project export workflows; Added tests for malformed settings file handling and multi-line tab session persistence; Added tests for resource node routing, icon composition, and text detection; Added tests for resource parsing security and utility classes; Added tests for sample plugin MEF composition; Added tests for signature comparison and WebCIL file validation; Added tests for the Search pane's input, mode, and result behaviors; Added tests for the XML documentation ID-string subsystem; Added tests for the assembly comparison feature; Added tests for the context-menu framework and specific menu entries; Added tests for the cross-platform ImageList decoder and tree-node integration; Added tests for the process explorer and diagnostics IPC client; Added tests for the update banner state logic; Added tests for theme-aware syntax highlighting and UI contrast; Added tests for type system sharing between tree and search; Added unit tests for the metadata filtering and tree-view infrastructure; Added unit tests for the new SharpTreeView control and omnibar features; Added unit tests for the pattern-matching engine; Expanded PDB sequence-point test cases for C\# language constructs; Expanded VB.NET decompiler test coverage; Expanded automated UI verification for the main window; Expanded correctness test suite for decompiler edge cases; Expanded test coverage for the decompiler editor and documentation views; New headless UI test infrastructure and fixtures for ILSpy; New test infrastructure and documentation for the decompiler test suite; Test coverage for the Analyzer pane and its context-menu actions; Test infrastructure updates for .NET 11 and cross-platform VB support.

The application now uses the Avalonia 12 DevTools (WithDeveloperTools) bridge, enabling the integrated developer tools in the Avalonia-based UI.

(dependencies) · high confidence

A README file has been added to the ILSpy Assets directory, providing a comprehensive table that lists the icons used in the application, their SVG status, and their specific origins (primarily the VS 2017 Icon Pack and FontAwesome). This entry documents the provenance of the visual assets for transparency and maintenance purposes.

ILSpy/Assets · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 67 → 66 (-1.4)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 78 → 75 (-3.2)
• Architecture 97 → 97 (-0.0)
• Maturity 68 → 70 (+1.9)
• Readiness 75 → 67 (-7.7)
• Security 78 → 77 (-1.6)
• Performance 61 → 60 (-0.5)

• BarePragmaDisable (ICSharpCode.Decompiler.Tests/Output/CSharpAmbienceTests.cs)
• BarePragmaDisable (ICSharpCode.Decompiler.Tests/Output/ILAmbienceTests.cs)
• BarePragmaDisable (ICSharpCode.Decompiler.Tests/TestCases/Correctness/Comparisons.cs)
• BarePragmaDisable (ICSharpCode.Decompiler.Tests/TestCases/Correctness/OverloadResolution.cs)
• BarePragmaDisable (ICSharpCode.Decompiler.Tests/TestCases/Pretty/CS73_StackAllocInitializers.cs)
• BarePragmaDisable (ICSharpCode.Decompiler.Tests/TestCases/Pretty/CustomTaskType.cs)
• BarePragmaDisable (ICSharpCode.Decompiler.Tests/TestCases/Pretty/CustomTaskType.cs)
• BarePragmaDisable (ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExpressionTrees.cs)
• BarePragmaDisable (ICSharpCode.Decompiler.Tests/TestCases/Pretty/Issue3598.cs)
• BarePragmaDisable (ICSharpCode.Decompiler.Tests/TestCases/Pretty/QualifierTests.cs)
• BarePragmaDisable (ICSharpCode.Decompiler.Tests/TestCases/Pretty/TypeMemberTests.cs)
• BarePragmaDisable (ICSharpCode.Decompiler.Tests/TestCases/VBPretty/ParameterizedProperties.cs)
• BarePragmaDisable (ICSharpCode.Decompiler.Tests/TypeSystem/TypeSystemTestCase.cs)
• BarePragmaDisable (ICSharpCode.Decompiler.Tests/TypeSystem/TypeSystemTestCase.cs)
• BarePragmaDisable (ICSharpCode.Decompiler/TypeSystem/IParameter.cs)
• BarePragmaDisable (ICSharpCode.Decompiler/TypeSystem/SpecialType.cs)
• Bounded contexts not declared
• Build status unknown
• CSharpConversions.BetterConversionTarget (cyclomatic 21) (ICSharpCode.Decompiler/CSharp/Resolver/CSharpConversions.cs)
• CSharpDecompiler.DoDecompile (cognitive 111) (ICSharpCode.Decompiler/CSharp/CSharpDecompiler.cs)
• …and 193 more

• Analyzer.CalculateLocalScopes (cognitive 53) (ICSharpCode.Decompiler/IL/Transforms/IntroduceScopedModifierOnLocals.cs)
• Analyzer.CalculateLocalScopes (cyclomatic 28) (ICSharpCode.Decompiler/IL/Transforms/IntroduceScopedModifierOnLocals.cs)
• Analyzer.GetInvocationEscapeToWritableArgument (cognitive 36) (ICSharpCode.Decompiler/IL/Transforms/IntroduceScopedModifierOnLocals.cs)
• Analyzer.GetInvocationEscapeToWritableArgument (cyclomatic 22) (ICSharpCode.Decompiler/IL/Transforms/IntroduceScopedModifierOnLocals.cs)
• Analyzer.GetInvocationEscapeWithUpdatedRules (cognitive 21) (ICSharpCode.Decompiler/IL/Transforms/IntroduceScopedModifierOnLocals.cs)
• Analyzer.Run (cognitive 42) (ICSharpCode.Decompiler/IL/Transforms/IntroduceScopedModifierOnLocals.cs)
• Analyzer.Run (cyclomatic 24) (ICSharpCode.Decompiler/IL/Transforms/IntroduceScopedModifierOnLocals.cs)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (ICSharpCode.Decompiler.Tests/.editorconfig)
• AnalyzerSeverityNone (ICSharpCode.Decompiler.Tests/.editorconfig)
• AnalyzerSeverityNone (ICSharpCode.Decompiler.Tests/.editorconfig)
• AnalyzerSeverityNone (ICSharpCode.Decompiler.Tests/.editorconfig)
• AnalyzerSeverityNone (ICSharpCode.Decompiler.Tests/.editorconfig)
• AnalyzerSeverityNone (ICSharpCode.Decompiler.Tests/.editorconfig)
• AnalyzerSeverityNone (ICSharpCode.Decompiler.Tests/.editorconfig)
• AnalyzerSeverityNone (ICSharpCode.Decompiler.Tests/.editorconfig)
• AssemblyListSnapshot.EnumerateAllAssembliesAsync (cognitive 21) (ICSharpCode.ILSpyX/AssemblyListSnapshot.cs)
• AssemblyTreeModel.NavigateOnLaunchAsync (cognitive 16) (ILSpy/AssemblyTree/AssemblyTreeModel.cs)
• BarePragmaDisable (ICSharpCode.Decompiler.Tests/TypeSystem/TypeSystemTestCase.cs)
• CSharpConversions.UserDefinedImplicitConversion (cyclomatic 16) (ICSharpCode.Decompiler/CSharp/Resolver/CSharpConversions.cs)
• …and 594 more

• 300 commits — 209 feature/other, 91 fixes

• (repo) — 84 commits
• ICSharpCode.Decompiler.Tests/TestCases — 37 commits
• ICSharpCode.Decompiler/IL — 36 commits
• ICSharpCode.Decompiler/CSharp — 22 commits
• (root) — 14 commits
• ICSharpCode.Decompiler.Tests/ProjectDecompiler — 8 commits
• TestTools/README.md — 7 commits
• ICSharpCode.Decompiler/TypeSystem — 6 commits
• .github/workflows — 5 commits
• ILSpy.Tests/Analyzers — 4 commits
• ILSpy.Tests/Search — 4 commits
• ILSpy/Languages — 4 commits
• ICSharpCode.Decompiler.Tests/DebugStepRecordingTests.cs — 3 commits
• ICSharpCode.Decompiler.Tests/Semantics — 3 commits
• ICSharpCode.Decompiler/Metadata — 3 commits
• ICSharpCode.ILSpyX/TreeView — 3 commits
• ILSpy.Tests/AssemblyList — 3 commits
• ILSpy.Tests/ContextMenus — 3 commits
• ILSpy/TreeNodes — 3 commits
• TestTools/decompdiff.cs — 3 commits

• fix: #2764: Add regression test for duplicate assembly references
• fix: Fix "Remove redundant comp(... != 0)" to avoid changing the value
• fix: Fix #1688: resolve elements to the XML namespace the document declares
• fix: Fix #2040: escape BAML strings that XML cannot represent
• fix: Fix #2054: repair a chain of type forwarders that cycles
• fix: Fix #2080: resolve GAC references onto the installed version
• fix: Fix #2093: find a navigation target in a reference assembly too
• fix: Fix #2372: report a field's address loads on their own
• fix: Fix #2823: write the async catch handler offset the way consumers read it
• fix: Fix #2919: keep a settings file that cannot be parsed
• fix: Fix #2930: follow references past the ones a document's assembly names
• fix: Fix #3008: local function forwarding a display class loses its scope
• fix: Fix #3154: accept single-file bundles as ilspycmd input
• fix: Fix #3290: marshal EnsureLazyChildren onto the tree's owning thread
• fix: Fix #3315: decode URI escapes in WPF resource names
• fix: Fix #3316: keep a plain property plain when its type does not resolve
• fix: Fix #3320: detect dynamic await in pre-Roslyn state machines
• fix: Fix #3526: show WPF resource entry names unescaped
• fix: Fix #3568: read a record's member order off its generated members
• fix: Fix #3683: insert casts in switch expression to ensure a best common type exists.
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

icsharpcode/ILSpy was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.