DevToys-app/DevToys

DevToys is a cross-platform desktop utility application that provides a suite of developer and general-purpose tools for text manipulation, encoding, and formatting. The system features a modular architecture supporting Windows, macOS, and Linux, with a Blazor-based UI layer that includes a rich component library and command-line interface. It enables users to perform operations like JSON formatting, Base64 encoding, and file conversion, while also supporting third-party extensions and smart data detection.

117 changes.

The project underwent a major architectural overhaul to support Windows, macOS, and Linux platforms, introducing a unified build system and a new Blazor-based UI framework. This period focused on establishing a modular, extensible core with a comprehensive set of reusable UI components and a plugin architecture for third-party extensions.

13 changes.

This period focused on expanding the Blazor-based UI with new data type detectors, converters, and organizational groups, while introducing command-line tool launching. It also significantly broadened internationalization support by adding localized strings for onboarding, updates, and platform-specific menus, alongside corresponding unit tests.

Introduced a new Chocolatey package for DevToys, enabling installation via the Chocolatey package manager. The package includes a nuspec file defining metadata and release notes, a PowerShell install script that validates Windows 10 build requirements and installs the MSIX bundle, and an update script to automate version and checksum updates from GitHub releases.

chocolatey · high confidence

Introduced new Blazor components for a CheckBox and a RadioButton, each including the Razor template, C\# code-behind, and SCSS styles. These components provide interactive, styled UI elements for selecting a single option (RadioButton) or toggling a state (CheckBox) within the DevToys Blazor application.

src/app/dev/DevToys.Blazor/Components/BasicInput/CheckBox, src/app/dev/DevToys.Blazor/Components/BasicInput/RadioButton · high confidence

Users can now run DevToys tools from the command line. The new DevToys.CLI entry point initializes a command-line interface using System.CommandLine, dynamically loading ICommandLineTool implementations via MEF and exposing them as CLI commands. The CLI also supports piping input from the terminal and logs output to both the console and a local file.

src/app/dev/platforms/desktop/DevToys.CLI · high confidence

Introduced a new command-line interface (CLI) framework for DevToys, defined by the ICommandLineTool interface which allows tools to be invoked via command-line arguments and return exit codes. Alongside this, a new ConsoleProgressBar class was added to provide animated, real-time progress updates in the console, handling text overwriting and timer-based updates. This establishes the foundation for running DevToys tools from the command line.

src/app/dev/DevToys.Api/Tool/CLI · high confidence

A new CSS file, app.css, was added to style the splash screen container and image, centering the logo and ensuring it scales appropriately within the viewport.

src/app/dev/DevToys.Blazor/wwwroot/css · high confidence

A new Container component has been introduced to the Blazor UI library, providing a flexible container that supports horizontal and vertical alignment (left, center, right, stretch, top, bottom) as well as explicit width, height, and padding/margin controls. This component wraps child content in a flexbox-based layout, enabling developers to easily manage the positioning and sizing of nested elements within the application's layout hierarchy.

src/app/dev/DevToys.Blazor/Components/Layout/Container · high confidence

Introduced a new Blazor ContextMenu component that displays a list of items on right-click, supporting icons, text labels, keyboard shortcuts, and disabled states. The component integrates with ContextMenuService for open/close lifecycle events and manages focus trapping and keyboard navigation within the menu.

src/app/dev/DevToys.Blazor/Components/Menu/ContextMenu · high confidence

Introduced a new DataGrid component in the Blazor UI library, enabling users to display and interact with tabular data. The component supports row and column selection, keyboard navigation, and interactive column resizing. It also provides templates for customizing cell and row detail rendering, with support for virtualized rendering of large datasets.

src/app/dev/DevToys.Blazor/Components/Collections/DataGrid · high confidence

Users can now use a new DropDownButton component that presents a list of items in a popover menu. The component supports headers, icons, and keyboard navigation, allowing users to select from a dynamic list of options via a dropdown interface.

src/app/dev/DevToys.Blazor/Components/BasicInput/DropDownButton · high confidence

Introduced new Blazor components for managing focus trapping and overlay rendering. The FocusTrapper component captures Tab and Shift+Tab key events to cycle focus between the first and last focusable elements within its content, ensuring keyboard navigation remains contained. The Overlay component provides a flexible overlay container with configurable z-index, visibility binding, and optional click handling, supporting both full-screen and child-fitting modes.

src/app/dev/DevToys.Blazor/Components/Layout/FocusTrapper · high confidence

Users can now use the new FontIcon component to display icons via UTF-32 glyphs, and the ProgressRing component to show indeterminate or determinate loading states with ARIA attributes for accessibility.

src/app/dev/DevToys.Blazor/Components/Feedback/FontIcon · high confidence

Introduced new layout components: FullScreenContainer, which manages full-screen mode toggling and focus restoration, and ScrollViewer, which provides customizable scrolling behavior (vertical, horizontal, or both) with support for native or custom scrollbars. These components enable developers to easily implement full-screen overlays and scrollable content areas in Blazor applications.

src/app/dev/DevToys.Blazor/Components/Layout/ScrollViewer · high confidence

Introduced new Blazor components for CSS Grid layout: the \Grid\ container, which accepts column and row definitions with configurable spacing, and the \GridCell\ child component, which places content into specific grid cells with support for spanning multiple columns or rows. These components enable users to build complex grid-based layouts directly in their Blazor applications.

src/app/dev/DevToys.Blazor/Components/Layout/Grid · high confidence

A new GridView component has been introduced to the Blazor UI library, enabling the display of grouped data in a scrollable, responsive grid layout. The component supports header and footer templates, group headers, and item templates, with JavaScript handling dynamic item sizing and sticky header clipping to ensure a polished user experience.

src/app/dev/DevToys.Blazor/Components/Collections/GridView · high confidence

Introduced new files in the Debugger namespace (DebuggerHelper.cs, HotReloadEventArgs.cs, HotReloadService.cs) to support Hot Reload functionality. HotReloadService implements the .NET MetadataUpdateHandler attribute to intercept Hot Reload requests and forward them via events (HotReloadRequestClearCache, HotReloadRequestUpdateApplication). The implementation includes a check for an active debugger attachment, suggesting this support is specifically tailored for debugging workflows.

src/app/dev/DevToys.Core/Debugger · medium confidence

Users can now use the new InfoBar component to display contextual feedback messages with four severity levels: information, success, warning, and error. The component supports optional icons, titles, messages, and action buttons, with styling that adapts to compact mode.

src/app/dev/DevToys.Blazor/Components/Feedback/InfoBar · high confidence

The application now includes new JavaScript modules (dom.js, monacoEditor.js) and their TypeScript sources to handle DOM interactions and Monaco Editor integration. The DOM module provides methods for managing focus, executing clipboard operations (cut, copy, paste, select all) on input and textarea elements, and registering document event listeners to communicate with the Blazor backend. The Monaco Editor module manages editor instances, allowing creation, disposal, and interaction with both single and diff editors, while also exposing methods for text manipulation and semantic highlighting.

src/app/dev/DevToys.Blazor/Assets/javascript · high confidence

The application now includes new JavaScript assets to support enhanced editing and layout capabilities. A new \devtoys.g.js\ file provides a wrapper for the Monaco Editor, enabling features like semantic token highlighting and diff editing. Additionally, \require.js\ is added to support the RequireJS module loader, and \split-grid.js\ is included to enable split-pane grid layouts. These files introduce new client-side dependencies that power the updated UI components.

src/app/dev/DevToys.Blazor/wwwroot/js · high confidence

Introduced a new Linux-specific implementation of the Blazor WebView component, including the \BlazorWebView\ and \BlazorWebViewManager\ classes, to enable web-based UI rendering on Linux desktops. The addition includes support for hot-reloading static content during development and defines URL loading strategies to control whether links open in the webview or externally.

src/app/dev/platforms/desktop/DevToys.Linux/Components · high confidence

Introduced a new Linux desktop platform implementation, including the main entry point, window management, and service initialization specific to the Linux environment. This enables the application to run natively on Linux systems using GTK and Blazor WebView.

src/app/dev/platforms/desktop/DevToys.Linux · high confidence

DevToys now supports Linux, introducing platform-specific implementations for core services. The new Linux core includes a Clipboard implementation that handles text, files, and images using GTK/GDK, a FileStorage service for managing application cache and temporary files, and a ThemeListener that detects system dark/light mode preferences via D-Bus and GTK settings. Additionally, a FontProvider exposes available system fonts, and a WindowService manages window state events. These changes enable the application to function natively on Linux desktops.

src/app/dev/platforms/desktop/DevToys.Linux/Core · high confidence

Introduced new Blazor components for rendering selectable lists. The \ListBox\ component supports both virtualized and standard item rendering, keyboard navigation, and selection state management via \SelectBase\. The \ListBoxItem\ component handles individual item selection, context menus, and visual states (selected, disabled, hover). Styles define the appearance of list items including selection indicators and compact mode support.

src/app/dev/DevToys.Blazor/Components/Collections/ListBox · high confidence

Introduced a new Popover component in the Blazor application, allowing developers to create floating UI elements that can be anchored to specific positions (top-left, top-center, top-right, center-left, center-center, center-right, bottom-left, bottom-center, bottom-right). The component supports configurable overflow behavior (flip never, flip on open, flip always), fixed positioning, relative width, and maximum height. A corresponding PopoverProvider component manages the rendering of these popovers, integrating with a PopoverService to handle fragment updates and lifecycle management.

src/app/dev/DevToys.Blazor/Components/Layout/Popover · high confidence

A new source generator, ResxHelperGenerator, has been added to the project. It automatically scans .resx files to detect available cultures and generates a C\# class (CultureHelper) containing a static array of supported culture strings. This enables applications to programmatically access the list of supported localizations without hardcoding them. The generator also includes MSBuild configuration files (Directory.Build.props and .targets) to ensure proper build integration.

src/generators · high confidence

Introduced a new SplitGrid component that provides a resizable, two-pane layout with a draggable gutter. The component supports both vertical and horizontal orientations, allowing users to adjust the size of each cell via a gripper handle. It integrates with the existing UI framework by inheriting from JSStyledComponentBase and managing the lifecycle of the underlying JavaScript library for split-pane functionality.

src/app/dev/DevToys.Blazor/Components/Layout/Expander, src/app/dev/DevToys.Blazor/Components/Layout/SplitGrid, src/app/dev/DevToys.Blazor/Components/Layout/StackPanel · high confidence

Introduced a new TextBlock component that renders styled text with support for multiple appearances (caption, body, title, etc.), text wrapping control, trimming, and highlighted spans. The component applies specific CSS classes and font styles based on the chosen appearance, enabling consistent text presentation across the application.

src/app/dev/DevToys.Blazor/Components/Text/TextBlock · high confidence

Introduced a new TextSpan record in the DevToys.Api namespace to represent a span of text defined by a start position and length. This API provides a structured way to handle text ranges, including calculating end positions and creating spans from start and end bounds, which supports text manipulation features within the application.

dev · high confidence

The Windows-specific visual theme for the Blazor app now includes both dark and light modes. The new \light.scss\ and \dark.scss\ files define CSS variables for colors, radii, and component states (buttons, checkboxes, cards), allowing the application to match the user's Windows theme preference.

src/app/dev/DevToys.Blazor/Assets/sass/theme/windows · high confidence

New PowerShell and Bash scripts (Install-DotNet, Restore-MonacoEditor) and configuration files (app-version-number.txt, monaco-editor-version-number.txt) were added to the tools directory. These scripts automate the installation of the .NET SDK and the download of the Monaco Editor, ensuring consistent build environments across Windows and Unix-like systems.

tools · high confidence

The application now includes new backend services to support a unified context menu and popup system, allowing for consistent UI interactions across the app. A new FontService has been added to dynamically load and inject third-party fonts into the document, ensuring consistent typography. Additionally, services for managing global dialogs (UIDialogService, GlobalDialogService) and document-level events (DocumentEventService) have been introduced to handle user interactions and state changes more reliably.

src/app/dev/DevToys.Blazor/Core/Services · high confidence

A new file-based logging implementation has been introduced, consisting of a \FileLogger\ and \FileLoggerProvider\ that write timestamped, structured log entries to text files. The provider manages the log directory, automatically deletes log files older than two days, and writes to a new file for each application instance. This change adds a concrete mechanism for persistent log storage, accessible via the \AddFile\ extension method.

src/app/dev/DevToys.Core/Logging · high confidence

The main layout now includes a FirstStartDialog and a WhatsNewDialog. The first-start dialog guides new users through the app's features and allows them to opt into update checks. The what's-new dialog displays the current version number and release notes in HTML format, providing users with information about recent changes.

src/app/dev/DevToys.Blazor/Pages · high confidence

The Windows desktop platform now includes new helper classes in the Core/Helpers directory to improve rendering and threading. DpiHelper provides device-independent pixel scaling transforms for accurate UI layout on high-DPI displays. ImageHelper enables conversion between WPF BitmapSource, System.Drawing.Bitmap, and MemoryStream representations, supporting PNG encoding and device-independent bitmap generation. ThreadHelper offers safe execution of actions and functions on the WPF UI thread, including async/await support and dispatcher priority handling.

src/app/dev/platforms/desktop/DevToys.Windows/Core/Helpers · high confidence

The 'Support Development' tool in the DevToys.Blazor application now includes its own localized resource files. The diff shows the addition of a C\# designer file and multiple .resx files (e.g., af-ZA, ar-SA, be-BY, bn-BD, ca-ES, cs-CZ, da-DK, de-DE, el-GR) containing translated strings for the tool's accessible name, description, and display title, enabling the interface to display in various languages.

src/app/dev/DevToys.Blazor/BuiltInTools/SupportDevelopment · high confidence

Added the \WhatsNewDialog\ resource files (\.resx\ and \.Designer.cs\) for multiple languages, including Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech, Danish, German, and Greek. These files provide the translated strings for the 'What's new in DevToys' dialog, specifically the title template and the 'Ok' button text.

src/app/dev/DevToys.Localization/Strings/WhatsNewDialog · high confidence

The Settings tool in the Blazor application now includes the necessary resource files to support internationalization. This change adds the C\# code-behind for the settings UI and the corresponding .resx localization files for multiple languages (including Afrikaans, Arabic, Belarusian, Bengali, Catalan, and Czech), enabling the application to display translated strings for settings such as app theme, compact mode, and update checks.

src/app/dev/DevToys.Blazor/BuiltInTools/Settings · high confidence

The application now includes a new set of localized string resources for the \UITextInputWrapper\ component. This change adds the \UITextInputWrapper.Designer.cs\ file and corresponding \.resx\ files for multiple languages (including Arabic, Czech, Danish, German, and others), enabling the interface to display translated text for actions such as Clear, Copy, Paste, Save as, and tool suggestions.

src/app/dev/DevToys.Localization/Strings/UITextInputWrapper · high confidence

The Mac OS desktop platform now includes localized string resources for the application menu bar, specifically for the 'Quit', 'Copy', 'Cut', 'Paste', 'Edit', and 'Select All' menu items. This change adds the necessary \.resx\ and \.Designer.cs\ files to support internationalization of these standard editing and application control commands on macOS.

src/app/dev/platforms/desktop/DevToys.MacOS/Strings · high confidence

Added a new set of native Windows interop classes in the DevToys.Windows.Native namespace, including enums and structs for DWM window attributes, accent policies, and window styles. These additions provide the underlying infrastructure for applying Windows-specific visual effects (such as acrylic and mica) and managing window behaviors (like hiding from Alt+Tab or extending frames), which supports the broader goal of improving the Windows desktop experience.

src/app/dev/platforms/desktop/DevToys.Windows/Native · high confidence

A new ComboBox component has been introduced in the BasicInput section, providing a dropdown selection interface with keyboard navigation, focus management, and support for virtualized or standard item rendering. The component includes styling for headers, button states, and list boxes, along with C\# logic for managing open/close states, scroll-to-selection, and escape key handling.

src/app/dev/DevToys.Blazor/Components/BasicInput/ComboBox · high confidence

A new Dialog component has been introduced to the application, providing a reusable modal overlay for displaying content and footers. The implementation includes a Blazor component (Dialog.razor and its code-behind) that manages open/close states, integrates with a GlobalDialogService, and handles focus trapping and dismissal. Styling is provided via a new SCSS file that defines the dialog's layout, shadow, and animation effects, with a provision to disable animations for users who prefer reduced motion.

src/app/dev/DevToys.Blazor/Components/Layout/Dialog · high confidence

A new ProgressBar component has been introduced to the application, providing both determinate and indeterminate visual feedback states. The component renders an SVG-based progress bar with styling for tracks, rails, and indeterminate animations, and includes accessibility attributes (aria-valuemin, aria-valuemax, aria-valuenow) for determinate mode.

src/app/dev/DevToys.Blazor/Components/BasicInput/ToggleSwitch, src/app/dev/DevToys.Blazor/Components/Feedback/ProgressBar · high confidence

A new polymorphic JSON converter and its factory have been added to the Blazor core library. This enables the serialization of interface and abstract types by delegating to the concrete type's serializer, which helps resolve JSON serialization issues for polymorphic scenarios.

src/app/dev/DevToys.Blazor/Core/Converters · high confidence

The repository now includes a Code of Conduct, Terms and Conditions for extensions, a Privacy Policy, a Security policy, and a Third-Party Notices file. These documents establish community standards, clarify liability for third-party extensions, and provide legal transparency for users and contributors.

(repo-wide) · high confidence

The Windows desktop application now features a splash screen that displays while the app loads, providing visual feedback to the user. Additionally, the Monaco editor library has been integrated into the application's web root, enabling advanced code editing capabilities within the app.

src/app/dev/platforms/desktop/DevToys.Windows/wwwroot · high confidence

The Monaco Editor component in the Blazor app has been significantly expanded with new C\# classes that map to the Monaco Editor TypeScript definitions. This includes comprehensive configuration options for the editor (EditorOptions), diff editor (DiffEditorOptions), and various sub-components like hover, find, and minimap settings. Additionally, a wide range of event classes (e.g., CursorPositionChangedEvent, ConfigurationChangedEvent) and supporting types (e.g., AccessibilitySupport, BuiltinTheme) have been added to support richer editor interactions and state management.

src/app/dev/DevToys.Blazor/Components/Text/MonacoEditor/Monaco · high confidence

The FirstStartDialog now includes new strings explaining the app's offline-first philosophy, a warning about third-party extension security, and a welcome message. These strings are provided in the English resource file and localized into multiple languages (e.g., Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech, Danish) via corresponding .resx files. Users will see updated onboarding text covering privacy, data collection, and extension trust policies.

src/app/dev/DevToys.Localization/Strings/FirstStartDialog · high confidence

Added a new Blazor WebView implementation for macOS, introducing a custom dispatcher, a WKWebView-based web view, and a manager to handle navigation and static content hot reload. This enables the application to render Blazor components within a native macOS web view, supporting features like CSS hot reload and controlled URL loading strategies for internal and external links.

src/app/dev/platforms/desktop/DevToys.MacOS/Controls · high confidence

Added a new \FileStorage\ implementation for the CLI environment, providing methods to read, write, and select files and folders via the console. This includes \OpenReadFile\, \OpenWriteFile\, and interactive pickers (\PickSaveFileAsync\, \PickOpenFileAsync\, \PickOpenFilesAsync\, \PickFolderAsync\) that prompt the user for input, validate file types, and handle path resolution relative to the application cache directory.

src/app/dev/platforms/desktop/DevToys.CLI/Core/FileStorage · high confidence

The macOS desktop application is now fully supported, introducing the native app entry point and lifecycle management via the new \AppDelegate\ and \Program\ classes. This change establishes the Mac-specific infrastructure, including the configuration of the service provider, logging, and extension installation folders, enabling the core Blazor-based UI to run on macOS.

src/app/dev/platforms/desktop/DevToys.MacOS · high confidence

A new Card component has been added to the Blazor UI library, providing a structured layout for displaying titles, descriptions, and controls. The component supports an optional header with an icon, title, and description, alongside a control or child content area. It also includes a compact mode that reduces the minimum height and padding for denser layouts.

src/app/dev/DevToys.Blazor/Components/Layout/Card · high confidence

The DevToys.Api project has been introduced as the official SDK for building third-party extensions. This includes the core API interfaces such as IMefProvider for dynamic component loading and IDataGridRow for data grid support, alongside a ViewModelBase for property change notifications. Additionally, MSBuild targets are configured to exclude specific DLLs (like CommunityToolkit and Microsoft.Extensions dependencies) from extension output folders, and the package is tagged for discoverability on NuGet.

src/app/dev/DevToys.Api · high confidence

A new TextBox component has been added to the Blazor UI library, supporting single-line text, search, password, and numeric input types. The component includes a header label, context menu (cut/copy/paste/select all), and specific controls for password visibility toggling, text clearing, and numeric value adjustment. It also supports compact mode for smaller layouts.

src/app/dev/DevToys.Blazor/Components/Text/TextBox · high confidence

The application now exposes a theme management system, allowing users to select between Light and Dark UI themes. Additionally, the interface supports a 'compact mode' to reduce visual clutter and animations, providing a more streamlined user experience.

src/app/dev/DevToys.Api/Core/Theme · high confidence

Added a set of Blazor components (presenters) that render the new UI element interfaces (such as Button, Card, DataGrid, FileSelector, Grid, and others) to the UI. These components handle the rendering logic, state propagation, and user interactions for the corresponding UI elements, enabling the application to use the new UI framework's visual components.

src/app/dev/DevToys.Blazor/Components/UIElements · high confidence

Added BlazorSandboxedFileReader and DevToysBlazorEmbeddedFileProvider to the Blazor core module. The file reader now uses the OneOf library to handle both browser and file system sources, addressing performance issues with the previous implementation. The embedded file provider enables access to embedded content via a standard IFileProvider interface.

src/app/dev/DevToys.Blazor/Core · medium confidence

Added a new MEF (Managed Extensibility Framework) implementation in the DevToys.Core module, including MefComposer, MefProvider, and a RecursiveDirectoryCatalog for scanning plugin folders. This change enables the application to dynamically discover and load third-party extensions and plugins from specified directories, supporting a more modular and extensible architecture for future plugin development.

src/app/dev/DevToys.Core/Mef · high confidence

The build system has been replaced with a new Nuke-based pipeline (src/build) that automates restore, compile, test, and publish steps for Windows, macOS, and Linux. This introduces platform-specific build targets, a unified configuration model, and cross-platform restore scripts (PowerShell for Windows, Bash for Unix) to streamline the developer and CI experience.

src/build · high confidence

Added a new NavBar component for the Blazor UI, featuring a sidebar with header, body, and footer regions, along with a corresponding NavBarItem component that supports expandable groups and separators. The implementation includes C\# code-behind, SCSS styles, and JavaScript modules for handling resize observers and keyboard shortcuts (Ctrl+F). This introduces a new navigation structure for the application.

src/app/dev/DevToys.Blazor/Components/Menu/NavBar · high confidence

Added new API components to support a dynamic, grouped tool interface in the application's main menu. This includes the IGuiTool interface for declaring tools with a graphical user interface, the GuiToolGroup class for organizing tools into categories, and PredefinedCommonToolGroupNames for standard groupings like 'Encoders / Decoders' and 'Formatters'. Additionally, IResourceAssemblyIdentifier and FontDefinition were added to enable dynamic font loading for tool icons and labels.

src/app/dev/DevToys.Api/Tool/GUI · high confidence

The application now uses a new \GuiToolInstance\ and \GuiToolProvider\ system to manage tool instances, metadata, and view models. This change introduces a \SmartDetectionService\ that automatically suggests tools based on detected data types, allowing the app to intelligently route clipboard or other input to the most relevant tool. Additionally, the codebase now supports grouping tools, managing favorites, and tracking recently used tools, providing a more dynamic and personalized user experience.

src/app/dev/DevToys.Core/Tools · medium confidence

Added MainWindowViewModel, ToolGroupPageViewModel, and ToolPageViewModel to handle the application's navigation, tool grouping (recent, favorite, and category-based), and individual tool page states. This includes logic for smart detection data passing, update notifications, and favorite tool management.

src/app/dev/DevToys.Business/ViewModels · high confidence

The application now supports smart detection for common data types such as text, JSON, XML, Base64, and images. This allows the app to automatically identify and handle clipboard content or other external data sources by recognizing their format, enabling seamless integration with relevant tools.

src/app/dev/DevToys.Api/Tool/SmartDetection · high confidence

Added a new Button component (Button.razor, Button.razor.cs, ButtonAppearance.cs, and associated SCSS) that supports four distinct visual styles: Neutral, Accent, Stealth, and Hyperlink. The component includes built-in handling for disabled states and a compact mode that reduces height and padding, providing a consistent, styled button element for the UI.

src/app/dev/DevToys.Blazor/Components/BasicInput/Button · high confidence

The application now uses a new settings system, defined by the ISettingsStorage interface and SettingsProvider implementation, to manage user preferences. This includes saving and restoring window position and size, storing the last version run, language, theme, recent tools, and text editor configurations. The provider handles serialization and deserialization of settings, supporting various data types and custom serialization logic.

src/app/dev/DevToys.Core/Settings · high confidence

Added new foundational components for the Blazor UI layer, including the IFocusable interface for managing focus, JSStyledComponentBase for handling JavaScript interop and disposal, MefComponentBase for dependency injection via MEF, Render.razor for child content rendering, and StyledComponentBase which provides common styling, layout, and visibility parameters (e.g., margin, padding, alignment) to all derived components.

src/app/dev/DevToys.Blazor/Components · high confidence

The MacOS application now includes a standard Edit menu in the menu bar, providing Cut, Copy, Paste, and Select All functionality. These menu items are wired to invoke the corresponding actions on the embedded web view, allowing users to perform common text editing operations within the app.

src/app/dev/platforms/desktop/DevToys.MacOS/Views · high confidence

Added MacOS-specific implementations for core platform services. The Clipboard service now supports text, files, and images using native NSPasteboard APIs. FileStorage provides access to app cache directories and implements file pickers (Open/Save) using native NSOpenPanel/NSSavePanel. WindowService manages window state, including a compact overlay mode that saves and restores window size, position, and zoom state. SettingsStorage uses NSUserDefaults for persistence. These changes replace previous cross-platform or stub implementations with native MacOS functionality.

src/app/dev/platforms/desktop/DevToys.MacOS/Core · high confidence

Added a new AutoSuggestBox component that provides a text input field with a dropdown list of suggestions. The component supports keyboard navigation (arrow keys, Enter, Escape), handles focus loss to close the dropdown, and exposes events for query changes and submission. It includes specific styling to ensure the dropdown overlay has the correct border radius and pointer events.

src/app/dev/DevToys.Blazor/Components/Text/AutoSuggestBox · high confidence

The application now includes new Blazor components for the Monaco text editor and diff editor. These components integrate the Monaco editor into the UI, supporting features like syntax highlighting, theme switching, and text editing. The diff editor component allows for side-by-side comparison of text, with support for highlighting differences. These components are styled to match the application's design system, ensuring consistent appearance across light and dark themes.

src/app/dev/DevToys.Blazor/Components/Text/MonacoEditor · high confidence

The DevToys API now includes a comprehensive set of new UI components for constructing tool interfaces, including buttons, cards, data grids, diff text inputs, dropdowns, file selectors, grids, and more. These components provide a consistent, extensible API for building the visual elements of DevToys tools, with support for properties like text, icons, selection, and event handling.

src/app/dev/DevToys.Api/Tool/GUI/Components · high confidence

Added new threading utilities in the Core/Threading namespace to improve asynchronous programming patterns. This includes an \AsyncLazy\<T\>\ class for asynchronous lazy initialization, a \DisposableSemaphore\ for managing concurrent task execution with automatic release, and several extension methods for \Task\ and \ValueTask\ such as \Forget\ and \ForgetSafely\ for fire-and-forget execution with optional error handling. Additionally, a \TaskSchedulerAwaiter\ is provided to switch execution context off the main thread, and a \CancellationTokenExtension\ converts cancellation tokens into tasks.

src/app/dev/DevToys.Api/Core/Threading · high confidence

The DevToys.Api.Core namespace now includes a set of new interfaces and utility classes to support the cross-platform architecture. This includes \IClipboard\ for managing clipboard data (text, files, images), \IFileStorage\ for handling file system interactions like opening, saving, and reading files, and \SandboxedFileReader\ for secure, read-only file access. Additionally, helper classes such as \ResultInfo\ for handling operation results, \ObservableHashSet\ for tracking collection changes, and extension methods for dictionaries and logging have been added to the core API.

src/app/dev/DevToys.Api/Core · high confidence

The DevToys.Core module introduces several new capabilities: AppHelper provides methods to detect preview/beta versions, parse command-line arguments, and check for application updates via GitHub; ExtensionOrderer adds topological sorting and cycle detection for third-party extensions; FileHelper manages temporary files and cleanup; and TitleBarInfoProvider exposes observable properties for window title bar layout and title text. These changes support better extension management, update notifications, and UI title bar customization.

src/app/dev/DevToys.Core · medium confidence

The application now includes new data type detectors for Base64 images and text, dates, files, GZip, images, JSON arrays, XML, and XSD, each implementing the IDataTypeDetector interface to identify specific data formats. Additionally, new UI group classes (Converters, Encoders/Decoders, Formatters, Generators, and Graphic) have been added to organize these tools in the interface, supported by localized resource strings for display titles and accessible names.

src/app/dev/DevToys.Blazor/BuiltInGroups · high confidence

Added three new helper structs/classes in the DevToys.Blazor.Core.Helpers namespace: CssBuilder, StyleBuilder, and ValueBuilder. These provide a fluent, conditional API for constructing CSS class strings and inline style strings, supporting conditional inclusion based on boolean flags or lambda expressions, and allowing nested builders. This enables components to more easily generate dynamic CSS and style attributes.

src/app/dev/DevToys.Blazor/Core/Helpers · high confidence

A new set of metadata attributes has been introduced to configure tool behavior and display. These include \AcceptedDataTypeNameAttribute\ for input type identification, \CommandLineOptionAttribute\ and \CommandNameAttribute\ for CLI tool definitions, \MenuPlacementAttribute\ for UI positioning, \NameAttribute\ for internal component naming, and \ToolDisplayInformationAttribute\ for UI resources like titles and descriptions. Additionally, an \IOrderableMetadata\ interface supports component ordering via \OrderAttribute\. These changes enable more granular control over how tools are discovered, displayed, and interacted with in the UI and command line.

src/app/dev/DevToys.Api/Tool/Metadata · high confidence

The application now uses a new \ISettingsProvider\ interface and supporting classes (\SettingDefinition\, \SettingChangedEventArgs\) to manage settings. This introduces a structured way to get, set, and reset settings, with automatic name generation to prevent collisions between extensions. Users benefit from a more robust and extensible settings system that supports custom serialization and deserialization callbacks for each setting.

src/app/dev/DevToys.Api/Settings · high confidence

Added shared configuration files (GlobalUsings.cs, LinkerConfig.xml, SharedAssemblyInfo.cs, SharedAssemblyVersion.cs) to support cross-platform builds on Linux, Mac, and Windows, including platform-specific assembly attributes and linker configurations to preserve required types.

src/app/dev/shared · high confidence

A new \CommandLineLauncherService\ has been added to handle command-line arguments, allowing users to launch specific tools directly from the command line. The service resolves the requested tool by its internal name and triggers the corresponding UI action, enabling a more integrated workflow for developers who prefer CLI interactions.

src/app/dev/DevToys.Business/Services · high confidence

The Windows desktop application now supports a compact overlay mode that keeps the window always-on-top with a smaller, fixed size, and an efficiency mode that reduces CPU and memory usage when the app is not in focus. Additionally, the app now supports taskbar jump lists for favorite tools and provides a new file storage API that returns file streams for better performance.

src/app/dev/platforms/desktop/DevToys.Windows/Core · high confidence

The extension manager now validates file paths during installation to prevent path traversal attacks (CWE-22 & CWE-23). This ensures that unpacked extension files cannot escape the designated installation directory, protecting the system from malicious or malformed extensions attempting to overwrite arbitrary files.

src/app/dev/DevToys.Blazor/BuiltInTools/ExtensionsManager · high confidence

A new global using directive for DevToys.Api has been added to the DevToys.Core project, making the DevToys.Api namespace available across all files in that project without requiring explicit namespace declarations.

src/app/dev/DevToys.Core/Properties · high confidence

The project has been reorganized into a new solution architecture that separates platform-specific builds for Windows, macOS, and Linux, each with their own solution file (e.g., DevToys-Windows.sln, DevToys-MacOS.sln, DevToys-Linux.sln). This change introduces a unified build system using Directory.Build.props and Directory.Build.targets to manage common properties, SDK versions, and build paths across all platforms. Additionally, an .editorconfig file has been added to enforce consistent code style and formatting rules for C\# and other project files, and a spellchecker exclusion dictionary has been introduced to handle specific technical terms.

src · high confidence

The application now manages supported languages and text flow direction through new core classes. Users can select from available languages, which updates the application's culture settings and adjusts the text flow direction (left-to-right or right-to-left) based on the selected language's properties.

src/app/dev/DevToys.Blazor/Core/Languages · medium confidence

The application now supports app update notifications and smart detection for text input controls. This is implemented by introducing a new \ChangeSelectedMenuItemMessage\ class to handle menu selection changes with optional smart detection info, and a \GitHubRelease\ model to parse GitHub release data for update checks.

src/app/dev/DevToys.Core/Models · medium confidence

The Windows desktop application now includes explicit resource dictionaries for dark and light themes. These new XAML files define color resources such as Foreground, FakeTransparentColor, ControlStrokeColorDefault, and ControlStrokeColorSecondary, enabling the application to support visual theme switching on Windows.

src/app/dev/platforms/desktop/DevToys.Windows/Properties, src/app/dev/platforms/desktop/DevToys.Windows/Themes · medium confidence

The application now includes dedicated dark and light theme stylesheets for Linux, defining CSS variables for colors, borders, and control states. This change improves the visual appearance of the interface on Linux desktops, making it look more native to the operating system.

src/app/dev/DevToys.Blazor/Assets/sass/theme/linux · medium confidence

A new class, DevToysLocalizationResourceManagerAssemblyIdentifier, has been introduced to the localization module. This class implements the IResourceAssemblyIdentifier interface and is registered as an export, providing a placeholder implementation for retrieving font definitions, which currently throws a NotImplementedException.

src/app/dev/DevToys.Localization · medium confidence

The ToolGroupPage now includes localized strings for key UI elements, including messages for when a tool is not found, options to open feature requests or suggest ideas on GitHub, and labels for opening links in a new window. These translations are provided in multiple languages (such as Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech, Danish, German, and Greek) via new .resx and .Designer.cs files, ensuring the interface displays correctly in those languages.

src/app/dev/DevToys.Localization/Strings/ToolGroupPage · high confidence

The application now includes new core services to support future functionality. The IVersionService allows the application to determine if it is a preview or beta version, while the IWebClientService provides a safe way to fetch web resources, returning null instead of crashing on errors.

src/app/dev/DevToys.Core/Version, src/app/dev/DevToys.Core/Web · medium confidence

The build system now automatically updates version numbers across the project. A new AppVersion build task reads version data and propagates it to C\# assembly attributes, the .csproj file, and the UWP appxmanifest, ensuring all components share a consistent version.

src/build/AppVersion · high confidence

The Blazor application now includes a centralized set of global using directives for ASP.NET Core components, JavaScript interop, and internal DevToys API and helper namespaces. This simplifies imports across the Blazor project.

src/app/dev/DevToys.Blazor/Properties · high confidence

The DevToys.Business module now explicitly grants internal access to all platform-specific assemblies (Windows, MacOS, Linux, Blazor, and the main app), enabling cross-platform functionality by exposing internal members to each target.

src/app/dev/DevToys.Business/Properties · high confidence

The Windows desktop application now uses a custom title bar and window chrome, replacing the default system title bar. This change introduces new controls (MicaWindowWithOverlay, OverlayControl, HwndHostEx) that enable a Mica-style header, custom minimize/maximize/close buttons, and improved window management. Users will see a more modern, consistent header across the app, with better support for window resizing, maximization, and Alt+Tab visibility. The change also fixes issues where the window could not be restored when maximized on Windows 10/11, and addresses a blank window appearing in Alt+Tab.

src/app/dev/platforms/desktop/DevToys.Windows/Controls · high confidence

The Blazor application entry point (Main.razor) and global imports (\_Imports.razor) have been added to define the routing and component namespace structure. Additionally, the project now includes a Gulp-based build pipeline (gulpfile.js) to compile SCSS and JavaScript assets, along with TypeScript configuration (tsconfig.json) and ESLint rules (.eslintrc.json) to support the frontend build process.

src/app/dev/DevToys.Blazor · high confidence

The CLI now stores application data in the local application data folder (e.g., AppData/Local/DevToys-CLI) rather than a generic cache directory, ensuring user data persists across sessions. Additionally, the command-line argument parser has been refactored to use a new \OneOf\-based parsing system, which improves the handling of complex types like \FileInfo\ and \DirectoryInfo\ by correctly validating their existence before parsing. This change also introduces helper extensions for type inspection, supporting more robust CLI interactions.

src/app/dev/platforms/desktop/DevToys.CLI/Core · high confidence

Added new extension methods to the Blazor core to improve JavaScript interop and data serialization. IJSRuntimeExtensions provides error-handling wrappers for JS invocations, ensuring that JS exceptions, disconnections, and cancellation do not crash the app. JsonExtensions introduces a helper to serialize .NET objects into dynamic objects that exclude null values, addressing a limitation in Blazor's default JSON serialization. WebUnitsExtensions adds helper methods to convert numeric values to CSS pixel or percentage strings.

src/app/dev/DevToys.Blazor/Core/Extensions · high confidence

The application now persists user settings in a local 'settings.ini' file, enabling cross-platform compatibility and supporting Linux environments. This change replaces previous storage mechanisms with a new 'SettingsStorage' implementation that reads and writes key-value pairs to disk, ensuring settings are retained across sessions on all supported desktop platforms.

src/app/dev/platforms/desktop/DevToys.CLI/Core/Settings · high confidence

The Windows desktop application has been rebuilt using WPF, integrating a BlazorWebView to render the UI. This change introduces Windows-specific features including DPI awareness, window position/size persistence, and title bar customization, while removing the previous WASDK/Uno implementation.

src/app/dev/platforms/desktop/DevToys.Windows · high confidence

The Blazor application's visual presentation has been restructured with new SCSS modules for layout, transitions, and typography. A new flexbox utility mixin provides consistent alignment and spacing for UI components. Animations have been reduced, with a new transition system allowing for faster, lighter entrance effects and the ability to disable them via the \[data-uselessanimations\] attribute. Typography is standardized with geometric text rendering and a reusable body style. Global resets enforce box-sizing, disable user selection/dragging, and style the Blazor error boundary.

src/app/dev/DevToys.Blazor/Assets/sass · high confidence

The macOS application now features dedicated dark and light theme stylesheets, introducing a native macOS aesthetic with specific control corner radii, text weights, and color palettes for UI components like buttons and checkboxes.

src/app/dev/DevToys.Blazor/Assets/sass/theme/macos · high confidence

The tool group and tool pages have been redesigned to improve the user experience. The tool group page now features a hero header with a parallax scrolling effect, a favorite button for tools, and an 'open in new window' action. The tool page includes a favorite toggle and hot reload support. Both pages support a compact mode that reduces padding and header height, and a reduced animations mode for performance.

src/app/dev/DevToys.Blazor/Pages/SubPages · high confidence

The application's icon assets in the \assets/font\ directory have been converted from individual SVG files into a compiled TrueType font (\DevToys-Tools-Icons\). This change replaces the previous method of rendering each tool's icon as a separate SVG file with a single font file, which allows the application to render icons more efficiently using standard font rendering techniques.

assets/font · high confidence

The application now uses a centralized SCSS file (\_default.scss) to manage theme variables and apply platform-specific styling for Windows, macOS, and Linux. This change introduces distinct dark and light themes for each operating system, ensuring that UI elements like fonts, colors, and focus states adapt to the native look and feel of the user's desktop environment. The theme transition effects have also been standardized across all platforms.

src/app/dev/DevToys.Blazor/Assets/sass/theme · high confidence

The localization resources for the file selector component have been updated with new translations and corrections. The C\# resource class and corresponding .resx files for multiple languages (including Arabic, Belarusian, Bengali, Catalan, Czech, Danish, and German) now contain the latest string values for UI elements such as 'Browse files', 'Drag & drop', and 'Paste'.

src/app/dev/DevToys.Localization/Strings/UIFileSelectorPresenter · medium confidence

The localized strings for the DevToys CLI have been updated, including new translations and corrections for various languages such as Arabic, Czech, Danish, and German. This ensures that user prompts and error messages in the command-line interface are accurately translated and displayed in the user's preferred language.

src/app/dev/platforms/desktop/DevToys.CLI/Strings · high confidence

The localized strings for the InfoBar component have been updated, including the 'CloseButtonAccessibleName' translation. This ensures that the accessible name for the close button on the info bar is correctly displayed in the user's selected language, improving accessibility and user experience for non-English speakers.

src/app/dev/DevToys.Localization/Strings/TextBox · high confidence

The localization files for the Linux desktop platform have been updated with new translations and corrections. This includes adding the \Other.Designer.cs\ code-behind file and multiple \.resx\ resource files for various languages (e.g., Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech, Danish, German), ensuring that UI strings such as 'Open', 'Save', and 'Cancel' are properly localized for Linux users.

src/app/dev/platforms/desktop/DevToys.Linux/Strings · high confidence

The TaskBar resource files have been updated with new translations for the 'Favorite tools' label across multiple languages, including Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech, Danish, German, and Greek. These changes ensure that the TaskBar interface displays the correct localized text for users with different language settings.

src/app/dev/platforms/desktop/DevToys.Windows/Strings/TaskBar · high confidence

The localization resources for the ToolPage have been updated with new translations for 'Add to favorites', 'OK', and 'Remove from favorites' across multiple languages including Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech, Danish, German, and Greek. These changes ensure that users see the correct translated text for these specific UI elements.

src/app/dev/DevToys.Localization/Strings/ToolPage · high confidence

The localized strings for the ImageViewer tool have been updated, including new translations for the Copy, Save As, Unknown Image, and View button labels across multiple languages such as Arabic, Czech, Danish, German, and others.

src/app/dev/DevToys.Localization/Strings/UIImageViewer · high confidence

The localization resources for the main window have been updated with new and corrected translations for multiple languages, including Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech, and Danish. These updates ensure that interface elements such as the search bar, navigation toggle, and update notifications are correctly displayed in the user's preferred language.

src/app/dev/DevToys.Localization/Strings/MainWindow · high confidence

The localized string resources for the API text component have been updated to reflect new translations for the 'SwitchOffDefaultText' and 'SwitchOnDefaultText' labels. This includes adding or correcting translations in multiple languages such as Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech, Danish, German, and Greek, ensuring that the default text for switch controls is correctly displayed in the user's preferred language.

src/app/dev/DevToys.Api/Strings · high confidence

The localized strings for the 'AllFiles' resource key have been updated across multiple language files (including Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech, Danish, German, and Greek). This change ensures that the text displayed in the open file dialog, which typically reads 'All {0}' (e.g., 'All PNG, JPG, GIF'), reflects the latest translations provided by the community.

src/app/dev/platforms/desktop/DevToys.Windows/Strings/Other · high confidence

The localized strings for the UIDataGrid component have been updated, including the addition of the 'Extend' and 'Shrink' button tooltips in multiple languages. This ensures that users see the correct translations for these UI elements.

src/app/dev/DevToys.Localization/Strings/UIDataGrid · high confidence

The WebView control now uses a composite file provider that combines the physical file system with embedded resources, ensuring that embedded assets are correctly resolved alongside physical files.

src/app/dev/platforms/desktop/DevToys.Windows/Controls/WebView · medium confidence

The app icon assets for macOS (Preview and Stable builds) and Windows/Linux (Preview and Stable builds) have been updated. These changes ensure the correct, high-quality SVG logo is displayed in the application interface and system menus on these platforms.

assets/logo · high confidence

Added mock implementations for unit testing; Added mock tools for unit testing; Added unit test infrastructure and test utilities; Added unit tests for Blazor core helpers; Added unit tests for NavBarState behavior; Added unit tests for UI element child lookup; Added unit tests for app update checking, extension ordering, and CLI parsing; Added unit tests for built-in Blazor data type detectors; Added unit tests for core utility classes; Added unit tests for the Blazor extension installation manager; Added unit tests for tool search and smart detection.

The project now uses a centralized package versioning file (Directory.Packages.props) to manage dependencies, including CommunityToolkit, xUnit, and various Microsoft.Extensions packages. Additionally, the build system now relies on Nuke.Common for the build script, and the Blazor project includes updated Node.js and TypeScript build tooling.

(dependencies) · high confidence

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

• CAI 43 → 41 (-2.3)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 63 → 44 (-19.3)
• Architecture 61 → 61 (-0.3)
• Maturity 56 → 47 (-9.2)
• Readiness 29 → 33 (+3.3)
• Security 77 → 92 (+14.9)
• Accessibility 49 → 45 (-4.3)
• Performance 70 → 70 (+0.0)

• Bounded contexts not declared
• Build did not complete in the analyzer
• Coverage not measured — analyzer environment
• Duplicated block (11 lines × 2) (src/app/dev/DevToys.Core/Tools/SmartDetectionService.cs)
• Duplicated block (11 lines × 2) (src/app/dev/platforms/desktop/DevToys.CLI/Core/Settings/SettingsStorage.cs)
• Duplicated block (14 lines × 2) (src/app/dev/DevToys.Blazor/Components/Feedback/ProgressBar/ProgressBar.razor.cs)
• Duplicated block (14 lines × 2) (src/app/dev/platforms/desktop/DevToys.CLI/Core/Settings/SettingsStorage.cs)
• Duplicated block (15 lines × 2) (src/app/dev/DevToys.Core/Tools/Metadata/GuiToolGroupMetadata.cs)
• Duplicated block (15 lines × 2) (src/app/dev/platforms/desktop/DevToys.CLI/Core/FileStorage/FileStorage.cs)
• Duplicated block (17 lines × 2) (src/app/dev/DevToys.Api/Core/ObservableHashSet.cs)
• Duplicated block (19 lines × 2) (src/app/dev/DevToys.Blazor/Components/UIElements/UIFileSelectorPresenter.razor.cs)
• Duplicated block (9 lines × 2) (src/app/dev/DevToys.Blazor/Components/Collections/DataGrid/DataGrid.razor.cs)
• FileTooLong: javascript/monacoEditor.ts (src/app/dev/DevToys.Blazor/Assets/javascript/monacoEditor.ts)
• Further orphaned files (smaller)
• Further sole-owners (lower concentration)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 22 more

• AnalyzerSeverityNone repeated across 21 files (packages/microsoft.codeanalysis.analyzers/3.11.0/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
• AnalyzerSeverityNone repeated across 21 files (packages/microsoft.codeanalysis.analyzers/3.11.0/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
• AnalyzerSeverityNone repeated across 21 files (packages/microsoft.codeanalysis.analyzers/3.11.0/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
• AnalyzerSeverityNone repeated across 21 files (packages/microsoft.codeanalysis.analyzers/3.11.0/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
• AnalyzerSeverityNone repeated across 21 files (packages/microsoft.codeanalysis.analyzers/3.11.0/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
• AnalyzerSeverityNone repeated across 21 files (packages/microsoft.codeanalysis.analyzers/3.11.0/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
• AnalyzerSeverityNone repeated across 21 files (packages/microsoft.codeanalysis.analyzers/3.11.0/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
• AnalyzerSeverityNone repeated across 21 files (packages/microsoft.codeanalysis.analyzers/3.11.0/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
• AnalyzerSeverityNone repeated across 21 files (packages/microsoft.codeanalysis.analyzers/3.11.0/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
• AnalyzerSeverityNone repeated across 21 files (packages/microsoft.codeanalysis.analyzers/3.11.0/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
• AnalyzerSeverityNone repeated across 21 files (packages/microsoft.codeanalysis.analyzers/3.11.0/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
• AnalyzerSeverityNone repeated across 21 files (packages/microsoft.codeanalysis.analyzers/3.11.0/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
• AnalyzerSeverityNone repeated across 21 files (packages/microsoft.codeanalysis.analyzers/3.11.0/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
• AnalyzerSeverityNone repeated across 21 files (packages/microsoft.codeanalysis.analyzers/3.11.0/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
• AnalyzerSeverityNone repeated across 21 files (packages/microsoft.codeanalysis.analyzers/3.11.0/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
• AnalyzerSeverityNone repeated across 21 files (packages/microsoft.codeanalysis.analyzers/3.11.0/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
• AnalyzerSeverityNone repeated across 21 files (packages/microsoft.codeanalysis.analyzers/3.11.0/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
• AnalyzerSeverityNone repeated across 21 files (packages/microsoft.codeanalysis.analyzers/3.11.0/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
• AnalyzerSeverityNone repeated across 21 files (packages/microsoft.codeanalysis.analyzers/3.11.0/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
• AnalyzerSeverityNone repeated across 21 files (packages/microsoft.codeanalysis.analyzers/3.11.0/editorconfig/PortedFromFxCopRulesEnabled/.editorconfig)
• …and 88 more

• Unchanged — 1 containers · 1 contexts · 0 edges

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

DevToys-app/DevToys 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.