Skip to content
CAI
Software that uses CAICheck a score

DevToys-app/DevToys

41.3

Weak · 10 November 2026

37.9k

lines of production code

C#

with JavaScript

8

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

DevToys is a cross-platform desktop utility application for developers, providing a suite of tools for encoding, decoding, formatting, and validating data. It features a modern Blazor-based UI with native window management on Windows, macOS, and Linux, and supports extensibility through a dynamic plugin system. The application includes smart detection for clipboard content, a command-line interface, and comprehensive localization support.

How it got here

2021–2023 — Blazor UI and cross-platform rewrite

117 changes.

The project underwent a major architectural shift, migrating the desktop interface to a cross-platform Blazor-based UI and upgrading to .NET 8. This period established a comprehensive extensibility framework with a MEF-based plugin system, declarative UI components, and a new API for third-party extensions. It also introduced native support for Linux and macOS alongside Windows, while implementing robust settings, localization, and smart detection infrastructure.

2024–2026 — Blazor migration and localization

13 changes.

This period focused on advancing the Blazor-based application by implementing core infrastructure such as polymorphic JSON serialization, command-line tool launching, and robust web services. Significant effort was dedicated to platform-specific enhancements, including native Linux theming, macOS menu localization, and updated application icons, alongside comprehensive localization for key dialogs. The work was supported by extensive unit testing for data type detectors, UI utilities, and extension installation security.

Features

Added AutoSuggestBox component for search input with suggestions

A new AutoSuggestBox component has been introduced to provide a search input field that displays a dropdown list of suggestions. The component supports keyboard navigation (arrow keys, Enter, Escape), custom item templates, and handles focus/blur events to manage the visibility of the suggestion list. It integrates with existing UI primitives like TextBox, ListBox, and Popover, and includes specific styling for the dropdown's border radius.

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

Added Blazor JavaScript interop layer and third-party libraries

The Blazor application now includes a dedicated JavaScript interop layer to support advanced UI components. This adds a Monaco Editor wrapper (devtoys.g.js) enabling code editing with semantic highlighting, diff editing, and clipboard operations, alongside a Split Grid library for resizable layout panes. Additionally, a modified SimpleBar library is included for custom scrollbars, and a global script prevents unwanted file drops on the window. These changes provide the underlying client-side functionality for the new code editor, split-view, and scrolling features in the Blazor UI.

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

Added Blazor sandboxed file reader and embedded file provider

Introduced BlazorSandboxedFileReader to handle file reading from both browser uploads and local file info using the OneOf library, and added DevToysBlazorEmbeddedFileProvider to serve embedded resources via the standard \_content/ path convention.

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

Added CheckBox and RadioButton components

New CheckBox and RadioButton components have been added to the BasicInput library. These Blazor components support standard properties such as Text, IsChecked, and Group (for radio buttons), and expose IsCheckedChanged callbacks to handle user interactions. They include full styling via SCSS for various states (hover, active, disabled) and implement the IFocusable interface to ensure proper keyboard navigation and focus management.

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

Added ComboBox component with keyboard navigation and virtualization support

A new ComboBox component has been introduced in the BasicInput library, providing a selectable dropdown list with header support, keyboard navigation (including Escape key handling), and optional virtualization for large item sets. The component integrates with the ContextMenuService to manage focus and state, ensuring proper accessibility and interaction behavior within the Blazor UI.

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

Added ContextMenu component with keyboard navigation and service integration

Introduced a new ContextMenu component for Blazor that displays a popup menu on right-click, supporting items with icons, text, and keyboard shortcuts. The component integrates with ContextMenuService to manage global state, handles keyboard navigation (including Tab key support), and provides lifecycle events for opening, opened, and closed states.

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

Added Expander component for collapsible content sections

Introduced a new Expander component that allows users to toggle the visibility of content sections. The component features a header card with an icon, title, and description that acts as a toggle button, supporting both mouse clicks and keyboard navigation (Enter/Space). When expanded, it reveals child content with a smooth animation, and it respects accessibility attributes like aria-expanded and tabindex for screen readers.

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

Added FontIcon and ProgressRing components to the Feedback section

This change introduces two new UI components for the Blazor application. The FontIcon component renders glyphs from font families (defaulting to FluentSystemIcons) using UTF-32 code points, supporting customization of size, rotation, and alignment. The ProgressRing component provides a visual indicator for loading states, supporting both determinate (0-100%) and indeterminate modes with appropriate ARIA attributes for accessibility.

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

Added Hot Reload support for .NET MAUI Blazor

The application now supports Hot Reload for .NET MAUI Blazor applications. This is implemented via a new \HotReloadService\ that registers a \MetadataUpdateHandler\ to intercept hot reload requests from Visual Studio, VS Code, or Rider. The service forwards these requests to clear caches and update the application, but only when a debugger is attached, ensuring the feature is available during development without affecting production behavior.

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

Added InfoBar component for displaying status messages

The InfoBar component is now available in the Feedback section, allowing the application to display contextual status messages with four severity levels: Informational, Success, Warning, and Error. Users can see these bars with optional icons, titles, and messages, and the component supports interactive action buttons and a close button for dismissing the notification. The visual appearance adapts to the severity level and includes a compact mode for smaller screens.

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

Added JavaScript DOM and Monaco Editor integration layer

The Blazor application now includes a dedicated JavaScript module to handle low-level browser interactions and code editing. This adds a DOM utility class for managing focus, clipboard operations (cut, copy, paste, select all), and document event subscriptions, while integrating the Monaco Editor library to provide syntax highlighting, semantic token support, and diff editing capabilities within the UI.

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

Added ListBox and ListBoxItem components with selection and keyboard navigation

Users can now use the new ListBox component to display a scrollable list of items with support for single selection, virtualization, and keyboard navigation (arrow keys, Enter, Space). The ListBoxItem component provides visual feedback for selected, hovered, and disabled states, including a compact mode for denser layouts, and supports custom context menus.

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

Added Popover component with positioning and overflow controls

Introduced a new Popover UI component in the Blazor layout library, allowing users to display floating content anchored to specific points. The component supports configurable anchor and transform origins (e.g., top-left, center-center), fixed or absolute positioning, and overflow behaviors such as flipping on open or always. It includes styling for open/close transitions, border radius, and backdrop filters, and integrates with a central PopoverService to manage multiple instances and render content fragments dynamically.

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

Added ResxHelperGenerator to detect and expose available application cultures

A new source generator (ResxHelperGenerator) has been added to the project. It scans .resx files within a C\# project to automatically detect all defined cultures and generates a static CultureHelper class containing an array of available culture strings. This enables applications to programmatically access the list of supported localizations without hardcoding them, addressing issues where specific languages (such as Chinese) were previously unavailable or not properly recognized.

src/generators · high confidence

Added SplitGrid layout component

Introduced a new SplitGrid component in the Blazor UI library that allows users to divide content into two resizable cells. The component supports both vertical and horizontal orientations, configurable cell sizes (fractional or absolute), and a minimum cell size constraint. It integrates with the split-grid JavaScript library to handle the drag-to-resize interaction via a visual gripper, ensuring proper cleanup of the split instance when the component is disposed.

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

Added Windows light and dark theme styles

The application now includes dedicated SCSS theme files for Windows (\dark.scss\ and \light.scss\) in the Blazor assets. These files define the visual appearance for both light and dark modes, specifying CSS variables for control colors, text weights, accent hues, button states, and card styling to match the Windows design language.

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

Added build and setup tooling scripts

New PowerShell and Bash scripts were added to the tools directory to automate environment setup and dependency management. Install-DotNet.ps1 and Install-DotNet.sh handle .NET SDK installation and version resolution via global.json, while Restore-MonacoEditor.ps1 and Restore-MonacoEditor.sh download and extract the Monaco Editor (version 0.39.0) into the application's wwwroot. Additionally, configuration files for app versioning (2.0.0) and a registry script to enable long paths on Windows are included.

tools · high confidence

Added core services for version detection and safe web requests

The application now includes a Version service that exposes whether the current instance is a preview or beta build, and a WebClient service that provides a safe method for downloading web resources as strings, returning null instead of crashing if an error occurs. These core services lay the groundwork for features like update notifications by providing reliable access to version state and network data.

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

Added file-based logging with automatic log rotation

DevToys now includes a new file logger that writes application logs to text files in the app's cache directory. This feature automatically clears log files older than two days to manage disk space, ensuring that users have persistent diagnostic logs without manual cleanup.

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

Added helper utilities for DPI scaling, image conversion, and UI thread management

The application now includes new helper classes in the Core/Helpers directory to support improved rendering and threading. DpiHelper provides methods to calculate device DPI and generate matrix transforms for accurate logical-to-device unit scaling, ensuring UI elements render correctly on high-DPI displays. ImageHelper introduces functionality to convert between WPF BitmapSource and System.Drawing.Bitmap objects, as well as handling PNG memory streams via ImageSharp, facilitating robust image processing. ThreadHelper offers safe utilities to check if code is running on the UI thread and to execute actions or functions asynchronously on the UI dispatcher, preventing cross-thread exceptions.

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

Added language and flow direction management

The application now includes a language management system that allows users to select from available supported cultures. This change introduces a LanguageManager that tracks the current culture and automatically adjusts the text flow direction (left-to-right or right-to-left) based on the selected language's properties, ensuring correct rendering for scripts like Arabic or Hebrew.

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

Added localization resource assembly identifier

Introduced a new component, DevToysLocalizationResourceManagerAssemblyIdentifier, which implements the IResourceAssemblyIdentifier interface to identify resource assemblies for the localization system. This change establishes the foundational structure for managing localized resources, though the font definition retrieval method is currently a placeholder.

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

Added localization resources for ToolPage favorites actions

The ToolPage now includes localized strings for the 'Add to favorites', 'OK', and 'Remove from favorites' actions. This change adds the strongly-typed resource class and corresponding .resx files for multiple languages (including Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech, Danish, German, and Greek), ensuring these specific UI elements are properly translated for users.

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

Added localization resources for the 'What's New' dialog

Added the resource files and strongly-typed resource class for the 'What's New' dialog, providing localized strings for the dialog title (e.g., 'What's new in DevToys v{0}') and the 'Ok' button across multiple languages including Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech, Danish, German, and Greek.

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

Added localization resources for the First Start Dialog

Added the resource files (Designer.cs and .resx files for multiple languages) for the First Start Dialog, providing localized strings for the welcome message, app description, offline-first philosophy explanation, extension trust warnings, and update check options.

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

Added localization resources for the Image Viewer tool

The Image Viewer tool now supports multiple languages. This change introduces the strongly-typed resource class and ResX files for the UI strings (Copy, Save as, View, Unknown image) in Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech, Danish, German, and Greek, ensuring the interface displays correctly in these locales.

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

Added localization resources for the InfoBar close button

Added the strongly-typed resource class and corresponding .resx translation files for the InfoBar component, providing localized strings for the close button's accessible name (e.g., "Close info bar") across multiple languages including Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech, Danish, German, and Greek.

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

Added localization resources for the Support Development tool

The Support Development tool now includes localized strings for its display title, description, and accessible name. This change adds the strongly-typed resource class and initial translation files (Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech, Danish, German, Greek, and others) to ensure the tool's interface is presented in the user's preferred language.

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

Added localization resources for the TaskBar 'Favorite tools' string

The application now includes the necessary resource files to display the 'Favorite tools' label in the TaskBar section for multiple languages, including Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech, Danish, German, Greek, and others. This ensures that users with these locale settings will see the interface text in their preferred language rather than a fallback or default string.

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

Added localization resources for the Tool Group Page

The application now includes localized strings for the Tool Group Page interface, supporting multiple languages including Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech, Danish, German, and Greek. These resources enable the UI to display messages such as 'Welcome to', 'Open in a new window', and 'Not finding what you're looking for?' in the user's selected language.

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

Added localization resources for the UITextInputWrapper component

Introduced a new strongly-typed resource class (UITextInputWrapper.Designer.cs) and corresponding .resx files for multiple languages (including Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech, Danish, and German) to support internationalization of the UITextInputWrapper. These resources provide localized strings for UI elements such as button labels (Clear, Copy, Paste, Save as, Load file) and tooltips (Extend, Shrink, More, Smart Detection), enabling the text input wrapper interface to display correctly in users' preferred languages.

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

Added localization resources for the file selector UI

The file selector component now supports internationalization. A new strongly-typed resource class and corresponding .resx translation files (including Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech, Danish, and German) have been added to provide localized strings for UI elements such as drag-and-drop prompts, file browsing actions, and selection status messages.

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

Added localization strings for Linux file dialogs

The Linux desktop build now includes localized resource files for common file dialog actions, such as Open, Save, and Cancel. This change adds the necessary string resources (e.g., in Afrikaans, Arabic, Czech, Danish, German, etc.) to support internationalization for these UI elements on Linux.

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

Added localization strings for UIDataGrid expand/shrink buttons

The UIDataGrid component now includes localized resource strings for the 'Extend' and 'Shrink' button tooltips, supporting multiple languages including Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech, Danish, German, and Greek. This ensures that users interacting with the data grid's full-screen expansion and contraction features see interface text in their preferred language.

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

Added localized CLI file operation prompts

The DevToys CLI now displays localized prompts when interacting with files and folders. This change introduces a new resource class (\CliStrings\) and corresponding \.resx\ files for multiple languages (including Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech, Danish, and German) to support user-facing strings for file operations such as opening, saving, and validating file paths.

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

Added localized strings for API switch controls

The API module now includes localized resource files for the default text of switch controls (On/Off states). This change adds the \ApiText.Designer.cs\ class and corresponding \.resx\ files for multiple languages (including Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech, Danish, German, and Greek), enabling the UI to display appropriate labels for switch toggles in the user's preferred language.

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

Added localized strings for macOS menu bar edit actions

The macOS desktop app now includes the resource files and designer code for the AppMenuBar, providing localized translations for the Edit menu items: Quit, Copy, Cut, Paste, and Select All. This enables these standard menu options to appear in the user's preferred language on macOS.

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

Added macOS-specific Blazor WebView controls and hot-reload support

This change introduces a new set of controls in the macOS platform layer to render Blazor web views using the native WKWebView component. It includes a custom dispatcher to ensure UI updates run on the main thread, a web view manager to handle navigation and JavaScript interop, and a static content hot-reload manager that allows CSS and other static assets to update without a full page reload during development. Additionally, it adds logic to handle URL loading strategies, allowing internal links to open within the app's web view while external links open in the default browser, and includes a fix for macOS 15 where '0.0.0.0' does not work for the app host address.

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

Added native Windows window styling and behavior helpers

The application now includes a new set of native Windows interop helpers in the \DevToys.Windows.Native\ namespace. These additions enable advanced window customization features, including support for modern acrylic/blur effects (Mica, AcrylicBlurBehind), rounded window corners, and DWM frame extension. Additionally, the codebase introduces utilities to control window visibility in the taskbar (hiding from Alt+Tab), manage system menu capabilities (minimize/maximize), and detect Windows Snap Layout settings, providing a foundation for a more polished and integrated Windows desktop experience.

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

Added new ProgressBar component

A new ProgressBar component has been added to the DevToys.Blazor feedback UI library. It supports both determinate and indeterminate modes, rendering an SVG-based progress indicator with accessible ARIA attributes (aria-valuemin, aria-valuemax, aria-valuenow) for determinate states and appropriate roles for indeterminate states. The component includes styling for smooth transitions and animations, allowing users to visualize task progress or ongoing background operations.

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

Added polymorphic JSON serialization support

The application now includes internal converters to handle polymorphic types during JSON serialization. This allows interfaces and abstract classes to be serialized by writing out the concrete type's data, ensuring that complex object hierarchies are correctly persisted and transmitted.

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

Automated build version management for Windows apps

A new build tooling component in src/build/AppVersion now automatically synchronizes version numbers across the project. It reads a central version definition and updates C\# assembly attributes (AssemblyVersion, AssemblyFileVersion, AssemblyInformationalVersion), the version specified in DevToys API project files, and the version attribute in Windows appx manifests, ensuring consistent versioning during the build process.

src/build/AppVersion · high confidence

Core infrastructure for extensions, updates, and UI state

This change introduces foundational services and interfaces within the core library to support new application capabilities. It adds an extension ordering system that uses topological sorting to manage dependencies and detect cycles among third-party extensions, enabling a more robust plugin architecture. It also implements a lightweight, custom update checker that compares the current app version against GitHub releases without requiring heavy SDKs, ensuring users are notified of new versions. Additionally, it provides utility helpers for managing temporary files, parsing command-line arguments, and detecting the operating system, while introducing UI-related interfaces (IGroup, IItem, ISeparator) and a provider for title bar metadata to support the new windowing and navigation experiences.

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

DevToys CLI introduces piped input support

The DevToys command-line interface now accepts input via standard input (piping). When the CLI detects that console input is redirected, it reads the piped content, cleans up any trailing newlines or byte-order marks, and appends it to the command-line arguments before execution. This allows users to pipe data directly into DevToys tools from other commands or scripts.

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

Establishes Blazor application structure and build tooling

The DevToys.Blazor project is initialized with the core files required to run a Blazor application, including the main router configuration (Main.razor), global imports (\_Imports.razor), and an ESLint configuration for TypeScript. Additionally, a Gulp build pipeline (gulpfile.js) and TypeScript configuration (tsconfig.json) are added to handle SCSS compilation and JavaScript bundling, with specific compiler settings noted to ensure compatibility with the Monaco editor.

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

Initial Chocolatey package support for DevToys

Added a new Chocolatey package (devtoys) that installs the DevToys application via an MSIX bundle. The package includes an installation script that verifies the user is on Windows 10 (build 18362 or later) before installing the app, an automatic update script to fetch the latest release from GitHub, and documentation for maintainers on how to generate and push new package versions.

chocolatey · high confidence

Initial Linux desktop support via GTK and Blazor WebView

DevToys now runs on Linux through a new desktop platform implementation. This change introduces a GTK-based native window that hosts a Blazor WebView, enabling the existing Blazor UI to function on Linux. The entry point initializes core services (MEF, logging, settings), manages the application lifecycle, and handles window title updates, providing the foundational runtime environment for the Linux desktop experience.

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

Initial Linux platform support with native clipboard, file, and theme handling

DevToys now runs on Linux, introducing platform-specific implementations for core services. The new Clipboard service supports copying and pasting text, files, and images (via PNG encoding/decoding). File operations use GTK file choosers and store data in the XDG-compliant cache directory. The ThemeListener detects system dark/light mode via DBus and GTK settings, while the WindowService manages window lifecycle events (activation, resizing, closing) and notes that window location tracking is unavailable on Wayland.

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

Initial macOS platform support for DevToys

This change introduces the foundational macOS application entry point and configuration for DevToys. It adds the \AppDelegate\ and \Program\ classes to initialize the native macOS app lifecycle, register core services (including Blazor WebView, MEF composition, and language services), and handle logging and exception management. Additionally, it includes the standard \Info.plist\ and \Entitlements.plist\ files required to define the app's identity, bundle structure, and permissions on macOS.

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

Initial release of the DevToys.Api SDK for extension development

This change introduces the DevToys.Api SDK, providing the foundational types and build configuration required to build third-party extensions for DevToys. The SDK includes core infrastructure such as ViewModelBase for property change notification, TextSpan for text manipulation, IDataGridRow for data grid integration, and IMefProvider for dynamic component loading. It also establishes MSBuild props and targets to ensure extensions are correctly tagged on NuGet and that shared dependencies (like CommunityToolkit and Microsoft.Extensions) are excluded from the extension output to prevent duplication.

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

Introduces core platform-agnostic APIs and utility types for clipboard, file storage, and results

This change adds the foundational API contracts and supporting types for the DevToys 2.0 core. It introduces \IClipboard\ for cross-platform clipboard interactions (text, files, and images), \IFileStorage\ for abstracted file system operations (picking, saving, reading, and writing), and \IFontProvider\ for accessing installed fonts. It also adds \SandboxedFileReader\ and \SimpleSandboxedFileReader\ to provide safe, concurrent read-only access to files, along with \ResultInfo\ and \ResultInfoSeverity\ to standardize success/failure reporting with optional severity levels. Utility extensions for \Dictionary\, \ObservableCollection\, \OneOf\, and \Logging\ are also included to support these core services.

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

Introduces first-run onboarding and version-specific 'What's New' dialogs

The application now presents a guided welcome experience on the initial launch, requiring users to agree to terms and configure update preferences before accessing the main interface. Subsequent updates trigger a 'What's New' dialog that displays formatted release notes, allowing users to review changes before dismissing the overlay. These changes are implemented via new \FirstStartDialog\ and \WhatsNewDialog\ components within the Blazor pages, which are orchestrated by the main \Index\ page to manage the startup flow and dialog state.

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

Introduces native macOS core services for clipboard, file storage, and window management

This change adds the foundational platform-specific implementations for the macOS desktop app, enabling core functionality that was previously missing or abstracted. Users gain native clipboard support that can now read and write text, files, and images (via PNG encoding) using the macOS pasteboard. File operations are backed by a new storage service that provides sandboxed file reading and native macOS save/open pickers for selecting single or multiple files and folders. Additionally, the app now manages window state more robustly, including saving and restoring window position and size across sessions, and implementing a compact overlay mode that adjusts window dimensions and z-order. Theme detection and compact mode behavior are also handled natively via system appearance observers and window size thresholds.

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

Introduction of CLI tooling infrastructure and console progress bar

This change introduces the foundational infrastructure for command-line interface (CLI) tools within the application. It adds the \ICommandLineTool\ interface, which defines how external tools are invoked via attributes (such as command names, aliases, and target platforms) and provides a standardized \InvokeAsync\ method for execution. Additionally, a new \ConsoleProgressBar\ class is added to provide animated, in-place progress updates in console windows, automatically handling output redirection to prevent garbage in log files. This enables developers to build and integrate CLI-based utilities with consistent user feedback and structured invocation.

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

Introduction of a structured settings provider API

The application now includes a new settings infrastructure consisting of the ISettingsProvider interface, SettingDefinition, and SettingChangedEventArgs. This allows the app to manage configuration values with type safety, support custom serialization logic, and notify listeners when settings change. Additionally, setting names are automatically prefixed with the calling assembly's name to prevent collisions between different components or extensions.

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

Introduction of dynamic MEF-based plugin system

The application now supports loading extensions dynamically from the 'Plugins' directory and subdirectories at runtime. This change introduces a Managed Extensibility Framework (MEF) composition layer that scans for assemblies, resolves dependencies, and exposes extension points via the DevToys.API, allowing third-party or user-provided plugins to be discovered and loaded without restarting the application.

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

Introduction of extensible smart detection framework for clipboard data

The SmartDetection module now provides a structured API for identifying data types from external sources like the clipboard. This change introduces the \IDataTypeDetector\ interface, allowing for pluggable detection logic that can parse raw data and return typed results via \DataDetectionResult\. It also defines a set of \PredefinedCommonDataTypeNames\ (such as JSON, XML, Base64, and GZip) to standardize how different data formats are recognized and routed to appropriate tools.

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

Introduction of theme management infrastructure

The application now includes a new theme management system within the Core/Theme module, introducing enums for application themes (Light, Dark) and available themes (Default, Light, Dark). A new IThemeListener interface has been added to expose the current system theme, app theme, actual applied theme, high contrast status, compact mode settings, and animation preferences, along with a ThemeChanged event and an ApplyDesiredColorTheme method to handle theme updates.

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

Linux support for Blazor WebView components

This change introduces the Linux-specific implementation of the Blazor WebView infrastructure, enabling Blazor-based tools to render correctly on Linux desktops. The new files in \src/app/dev/platforms/desktop/DevToys.Linux/Components/BlazorWebView\ provide the \BlazorWebView\ control and its manager, which bridge the .NET Blazor runtime with the native WebKitGTK web view. This includes handling URL loading strategies (opening internal links in the web view and external links in the system browser), managing root components, and supporting static content hot reload for CSS updates during development. These components are essential for fixing the blank window and navigation crashes previously experienced on Linux, allowing the application to display its Blazor UI elements properly.

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

Monaco Editor configuration and event model expanded

The Monaco Editor component now exposes a significantly broader set of configuration options and event types, enabling finer control over editor behavior and better integration with host applications. Users can now configure advanced features such as bracket pair colorization, inline inlay hints, sticky scroll, and detailed minimap rendering, while also gaining access to granular editor events like cursor selection changes, content size updates, and configuration changes. This expansion allows for more precise customization of the editing experience and more robust handling of editor state changes in Blazor applications.

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

New Blazor Button component with multiple appearances and compact mode

A new Button component has been added to the Blazor UI library, supporting four distinct visual styles: Neutral, Accent, Stealth, and Hyperlink. The component respects disabled states by preventing pointer events and applying specific disabled styling, and it includes a compact mode that reduces the button's minimum height and padding when rendered inside a container with the 'data-compactmode' attribute.

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

The application now uses a new Blazor-based NavBar component (NavBar.razor) that features an adaptive sidebar which automatically hides or collapses based on window width, supports an expanded overlay mode, and includes an integrated search bar (AutoSuggestBox) with Ctrl+F keyboard shortcut support. The sidebar items support grouping with expandable children, and the layout adjusts dynamically to footer height changes.

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

New Blazor UI element presenters for core controls

The application now includes a comprehensive set of Blazor component presenters in the UIElements folder, enabling the rendering of various UI elements such as buttons, cards, data grids, drop-down buttons, file selectors, icons, image viewers, and text inputs. These presenters bridge the internal UI model (e.g., IUIButton, IUIDataGrid) to the actual Blazor UI components, handling layout, styling, and user interactions like file selection, drag-and-drop, and full-screen toggling.

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

New Blazor component infrastructure for styling and JavaScript interop

The DevToys Blazor application now includes a new internal component hierarchy in the Components folder to support consistent styling, layout, and JavaScript integration. This introduces a base \StyledComponentBase\ that provides parameters for CSS classes, inline styles, margins, padding, visibility, and alignment, along with logic to aggregate CSS classes. It also adds \JSStyledComponentBase\ for managing JavaScript module imports and disposal, \MefComponentBase\ for MEF dependency injection integration, \IFocusable\ for focus management, and a \Render\ component for rendering child content. These changes lay the groundwork for the new UI system mentioned in the commit messages.

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

New CSS, Style, and Value builder helpers for Blazor components

Added three new helper structs/classes in the Core/Helpers namespace to simplify building conditional CSS classes, inline styles, and complex style values in Blazor components. CssBuilder allows chaining class additions with prefixes and conditional logic, StyleBuilder provides similar fluent methods for inline styles (including !important support and attribute extraction), and ValueBuilder assists in constructing space-separated value lists for style properties.

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

New Card layout component with compact mode support

A new Card component has been added to the Blazor UI library, providing a styled container for displaying titles, descriptions, icons, and child content. The component supports a compact mode (triggered via a data attribute) that reduces the minimum height and padding, allowing for denser layouts. It also integrates with the Expander component to adjust spacing when nested inside one.

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

New Container layout component with flexbox alignment

A new Container component has been added to the layout system, providing a flexbox-based wrapper for child content. It supports configurable horizontal and vertical alignment (stretch, left, right, center, top, bottom), margins, padding, and explicit width/height constraints. The component also handles visibility toggling via CSS display properties and propagates an enabled state to its descendants using a CascadingValue.

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

New DataGrid component with column resizing and row selection

The DataGrid component in the Blazor UI library is now available for displaying tabular data. It supports row selection with keyboard navigation, row detail expansion, and virtualized rendering for large datasets. Users can also resize columns by dragging the column headers, with the grid automatically adjusting adjacent columns to maintain layout integrity.

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

New Dialog component with focus management and reduced animations

A new Dialog component has been added to the application layout, providing a modal overlay with support for custom content and footers. It integrates with the GlobalDialogService for state management and implements keyboard navigation, including focus trapping and Escape key dismissal. The component also respects a 'reduced animations' preference, disabling visual transitions when the user has opted out of them.

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

New DropDownButton component for Blazor UI

A new DropDownButton component has been added to the BasicInput library, allowing users to display a button that opens a popover list of menu items. The component supports customizable headers, tooltips, and arrow display, and integrates with the ContextMenuService to manage focus and closing behavior. It renders a list of DropDownListItem objects, each supporting text, icons (using FluentSystemIcons), enabled/disabled states, and click callbacks, with styling for headers, buttons, and the dropdown popover.

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

New FocusTrapper and Overlay layout components

Added the FocusTrapper component to trap keyboard focus within a container, cycling focus between the first and last focusable elements on Tab/Shift+Tab and supporting an OnEscapeKeyPressed callback, and the Overlay component to render a fixed-position, clickable backdrop that can optionally fit its child content.

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

New GUI tooling API and resource infrastructure

The application introduces a new extensibility model for tools with graphical interfaces, defined by the \IGuiTool\ interface which allows plugins to declare their UI view, accepted data types, and metadata (such as icons, group placement, and search keywords) via attributes. This is supported by \GuiToolGroup\ for organizing tools into menu categories (e.g., Encoders, Converters) and \IResourceAssemblyIdentifier\ to enable dynamic loading of custom fonts and localized strings from plugin assemblies. Additionally, \FontDefinition\ and \PredefinedSupportedImageFormats\ provide the underlying infrastructure for handling dynamic font resources and standard image extensions within this new tooling framework.

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

New Grid and GridCell layout components

Added the Grid and GridCell Blazor components to enable CSS Grid-based layouts. The Grid component accepts parameters for Columns, Rows, ColumnSpacing, and RowSpacing to define the grid structure, while GridCell allows children to specify their Column, Row, ColumnSpan, and RowSpan positions within that grid.

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

New GridView component with sticky headers and dynamic sizing

A new GridView component has been added to the Blazor UI library, enabling the display of grouped collections with sticky group headers and dynamic item sizing. The component supports customizable headers, footers, and item templates, while JavaScript logic ensures that group headers remain visible during scrolling and that items automatically adjust their width to fill the available container space.

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

New Monaco Editor and Diff components for Blazor

The text editing experience in the Blazor app is upgraded with new \MonacoEditor\ and \MonacoEditorDiff\ components. These components provide a rich, syntax-aware code editor with features like hover tooltips, bracket pair colorization, and automatic layout. The diff editor allows side-by-side comparison of text changes. Both components integrate with the application's theme system (supporting dark and light modes) and respect global user settings for font family, line highlighting, whitespace rendering, and text wrapping.

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

New TextBlock component with theme-aware styling and text highlighting

A new TextBlock component has been added to the Blazor UI library, providing a styled text display element that supports multiple appearance presets (Caption, Body, BodyStrong, BodyLarge, Subtitle, Title, TitleLarge, Display) mapped to specific HTML tags and CSS classes. The component allows users to control text wrapping (NoWrap), truncation with ellipsis (CanTrim), and visibility states. It also supports inline text highlighting via HighlightedSpans, which wraps specified text ranges in \<mark\> tags using theme-defined selection colors. The styling is driven by CSS variables for fonts, weights, and colors, ensuring consistency with the application's light and dark themes.

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

New TextBox component with number input and password support

The TextBox component in the Blazor UI library has been introduced, providing a versatile text input control that supports multiple input types including standard text, search, password, and number fields. Users can now utilize number inputs with configurable minimum, maximum, and step values, along with increment/decrement buttons. The component also features password visibility toggling, context menu support (cut, copy, paste, select all), and a compact mode for denser layouts. It respects system font settings and includes styling for disabled, focused, and hover states.

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

New Windows core services for clipboard, efficiency mode, and compact overlay

This location introduces several new core services for the Windows desktop application. The Clipboard service now supports retrieving and setting text, files, and images (including PNG and bitmap formats). An EfficiencyModeService automatically throttles the process priority and power settings when the app is in the background to reduce system interference. A WindowService manages a new Compact Overlay mode, allowing the main window to be pinned on top with a fixed, smaller size. Additionally, a TaskbarJumpListService dynamically updates the Windows taskbar jump list with favorite tools, and a ThemeListener handles system theme changes and compact mode detection based on window size.

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

New asynchronous threading utilities added to the API core

The API core now includes a new \DevToys.Api.Core.Threading\ namespace containing several helper classes and extensions to improve asynchronous programming patterns. This includes an \AsyncLazy\<T\>\ class for asynchronous lazy initialization, a \DisposableSemaphore\ for managing concurrent task execution with automatic resource release, and a \TaskSchedulerAwaiter\ to facilitate switching execution contexts off the main thread. Additionally, \TaskExtensions\ and \CancellationTokenExtension\ provide utility methods for fire-and-forget task execution (\Forget\, \ForgetSafely\), synchronous completion (\CompleteOnCurrentThread\), and converting cancellation tokens to tasks.

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

New core services for context menus, dialogs, popovers, and language support

This change introduces a set of new backend services in the Blazor application to power interactive UI features. ContextMenuService manages context menu state and automatically closes menus on window events. GlobalDialogService and UIDialogService coordinate modal dialog opening and closing to ensure only one dialog is active at a time. PopoverService and PopoverHandler provide the infrastructure for rendering and managing floating popover elements. FontService enables dynamic loading of third-party fonts by converting them to base64 and injecting CSS. DocumentEventService bridges .NET and JavaScript to subscribe to and handle DOM events. Finally, MonacoLanguageService integrates with the Monaco editor to provide auto-completion and semantic tokenization for various programming languages.

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

New data type detectors and tool groups for DevToys Blazor

The Blazor application now includes a comprehensive set of built-in data type detectors that automatically identify content such as Base64 images, Base64 text, dates, files, GZip text, images, JSON arrays, JSON objects, plain text, XML, and XSD schemas. These detectors are organized into new UI tool groups—Converters, Encoders/Decoders, Formatters, Generators, and Graphic—complete with localized display titles and accessible names to improve navigation and usability within the app.

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

New declarative UI component API for building tool interfaces

The tool's user interface is now constructed using a new declarative API defined in the \DevToys.Api\ namespace. This change introduces a comprehensive set of UI components—including buttons, cards, data grids, file selectors, drop-down menus, grids, and various text inputs—along with their underlying interfaces and implementations. Users can now build tool layouts by composing these elements, leveraging features such as row selection in data grids, file extension filtering in selectors, and flexible grid layouts with configurable spacing.

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

New layout components: ScrollViewer and FullScreenContainer

The application now includes two new layout components in the Blazor UI framework. The ScrollViewer component provides customizable scrolling behavior, supporting vertical, horizontal, or both axes, with options to use native browser scrollbars or a custom SimpleBar implementation, and includes a programmatic method to scroll to specific child elements. The FullScreenContainer component enables toggling content into a full-screen mode, handling the DOM manipulation to move elements in and out of the full-screen view while managing focus restoration.

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

New metadata attributes for tool configuration and display

This change introduces a new set of metadata attributes in the \DevToys.Api\ tool metadata layer to define how tools are identified, ordered, and displayed. Developers can now use \CommandNameAttribute\ and \CommandLineOptionAttribute\ to configure CLI commands, \AcceptedDataTypeNameAttribute\ and \DataTypeNameAttribute\ to link tools with data type detectors for smart detection, and \OrderAttribute\ to specify component ordering relative to others. UI presentation is controlled by \ToolDisplayInformationAttribute\ (for titles, descriptions, icons, and localization), \MenuPlacementAttribute\ (to place tools in the body or footer), and \TargetPlatformAttribute\ (to restrict tools to Windows, macOS, or Linux). Additional attributes like \NameAttribute\, \NoCompactOverlaySupportAttribute\, \NotFavorableAttribute\, and \NotSearchableAttribute\ allow fine-grained control over tool visibility and behavior.

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

New tool management and smart detection infrastructure

This change introduces the core backend services for the DevToys tool menu, including the GuiToolProvider which manages tool instances, favorites, and recent tools, and the SmartDetectionService which analyzes clipboard data to recommend relevant tools. It also adds metadata models for tool configuration and view models for the menu UI, enabling features like smart detection, tool grouping, and dynamic menu updates.

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

Repository initialization with documentation, build scripts, and configuration

The repository is initialized with essential project documentation including a Code of Conduct, Privacy Policy, Security policy, and Third-Party Notices. Build and initialization scripts (build.sh, build.ps1, init.sh, init.ps1) are added to handle .NET installation, dependency restoration, and Monaco Editor setup across Windows, macOS, and Linux. Configuration files for .NET 8.0 SDK, NuGet, and Crowdin localization are included, along with a Visual Studio 2022 workload configuration and updated .gitignore rules.

(repo-wide) · high confidence

Settings tool localization and font resource identification

The Settings tool now supports multiple languages through the addition of localized resource files (e.g., Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech) and a strongly-typed resource manager. Additionally, the application now explicitly identifies and registers the FluentSystemIcons and DevToys-Tools-Icons font assets via a new resource assembly identifier.

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

Support for launching tools via command line arguments

Users can now launch specific DevToys tools directly from the command line by passing a tool name argument. This new service parses command-line inputs to identify requested tools and automatically navigates the application interface to the corresponding tool view, enabling programmatic access to individual tools without manual navigation.

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

Support for smart detection and app update notifications

The application now supports smart detection for text input controls, allowing tools to be automatically identified and launched based on context. Additionally, the app includes a new mechanism for notifying users about available updates via GitHub releases. These changes are implemented through new model classes: \ChangeSelectedMenuItemMessage\ handles the smart detection logic by carrying information about detected tools, and \GitHubRelease\ models the data structure for parsing release information from GitHub.

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

Security

Extensions manager now validates installation paths and filters platform-specific binaries

The ExtensionsManager now prevents path traversal vulnerabilities (CWE-22 & CWE-23) by validating that extracted files remain within the designated extension folder during installation. Additionally, the manager filters out runtime binaries that do not match the user's current operating system and architecture, ensuring that only compatible native components are installed.

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

Architecture

Introduced Nuke-based build automation

The build system has been replaced with a new Nuke-based automation framework. This change introduces a structured build pipeline (Build.cs) that handles dependency restoration, compilation, testing, and publishing across Windows, macOS, and Linux environments. It includes platform-specific logic for restoring dependencies (using PowerShell on Windows and Bash on Unix-like systems) and publishing applications, along with standardized MSBuild properties (Directory.Build.props) and C\# coding style rules (.editorconfig) to ensure consistent builds.

src/build · high confidence

New cross-platform solution structure and build configuration

The project has been reorganized into a new solution architecture featuring platform-specific solution files for Windows, macOS, and Linux, alongside a shared core. This change introduces a .NET 8 target framework, enforces centralized package management, and adds an .editorconfig to standardize code formatting and style rules across the codebase.

src · high confidence

Behavioural changes

Added Blazor Web App entry point with splash screen and Monaco Editor support

The desktop application now uses a new HTML entry point (index.html) to host the Blazor Web App. This page initializes the Blazor runtime, loads the application styles and scripts, and displays a splash screen image while the app loads. It also integrates the Monaco Editor library for code editing capabilities and includes an error UI for handling unhandled exceptions.

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

Added WPF-specific theme resources and assembly metadata

The Windows desktop application now includes explicit WPF assembly metadata and dedicated resource dictionaries for Dark and Light themes. These changes define specific color resources (such as foreground, fake transparent, and control stroke colors) and register the application as Windows-specific, supporting the underlying UI framework requirements.

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

Added global using for DevToys.Api in DevToys.Core

The DevToys.Core module now automatically includes the DevToys.Api namespace in all its source files via a new global using directive, simplifying access to API-related types without requiring explicit imports in individual files.

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

Added global usings for Blazor and API integration

The Blazor application now automatically imports core namespaces for ASP.NET Core Components, JavaScript interop, and internal DevToys API helpers, simplifying code in individual files by removing the need for explicit using directives.

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

App icons are now rendered from a TTF font instead of SVG files

The application's tool icons have been migrated from individual SVG assets to a TrueType font (TTF). This change replaces the previous SVG-based rendering with a font-based approach, which is managed via FontForge and documented in the updated \README.md\ within the \assets/font\ directory.

assets/font · high confidence

Assembly visibility updated for cross-platform Blazor targets

The DevToys.Business assembly now explicitly exposes its internals to the specific platform assemblies: DevToys.Blazor, DevToys.Windows, DevToys.MacOS, DevToys.Linux, and the generic DevToys assembly. This change supports the new cross-platform architecture where different UI layers (WPF Blazor on Windows, MAUI Blazor on Mac, and Linux support) share business logic, ensuring that internal members required by these distinct platform implementations are accessible.

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

CLI file storage now uses console-based prompts for file operations

The DevToys CLI now implements file storage interactions via the console rather than native OS dialogs. Users will see text prompts in the terminal to specify file paths for opening, saving, and selecting folders, with support for comma-separated multiple file paths and automatic trimming of surrounding quotes. The service also resolves relative paths against the application cache directory and validates file types against provided filters.

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

CLI now uses local app data and supports OneOf option parsing

The DevToys CLI now stores its cache and temporary files in the user's local application data directory (e.g., %LOCALAPPDATA%\\DevToys-CLI) instead of a generic location, ensuring better isolation and persistence. Additionally, the command-line argument parsing engine has been updated to support \OneOf\<\>\ types, allowing options to accept multiple distinct data types (such as \FileInfo\, \DirectoryInfo\, \DateTime\, etc.) with robust string-to-type conversion logic.

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

Custom Mica title bar and window chrome for Windows

The Windows desktop application now uses a custom \MicaWindowWithOverlay\ control to render the window frame, title bar, and system buttons (minimize, maximize, close) instead of the default OS chrome. This change introduces a native-style Mica background and allows for a compact title bar appearance. It also fixes a bug where a blank window appeared in the Alt+Tab switcher by hiding the underlying overlay window from the task switcher.

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

Establishes shared cross-platform configuration and global usings

The shared project now centralizes global using directives and platform-specific assembly attributes to support cross-platform builds. It explicitly defines supported OS platforms (iOS 14.0+, macOS 12.0+, Linux, and Windows 10) via conditional compilation symbols, ensuring the application correctly targets the appropriate environments. Additionally, a linker configuration file is introduced to preserve critical assemblies (such as DevToys.Core, DevToys.Blazor, and system libraries) from being trimmed during publishing, preventing runtime errors related to reflection and dynamic loading.

src/app/dev/shared · high confidence

Introduce INI-based settings storage for CLI

The CLI application now persists user configuration in a local \settings.ini\ file. This new \SettingsStorage\ component reads and writes key-value pairs to this file, replacing any previous in-memory or alternative storage mechanism for CLI settings.

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

Introduction of a new settings infrastructure

The application now uses a new settings system that persists user preferences, such as theme, language, and text editor options, across sessions. This change enables features like saving window position and size, remembering the last version run, and managing recent tools, ensuring that user configurations are restored when the app is reopened.

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

Native Linux dark and light theme styles added

The application now includes dedicated Sass theme files for Linux (\dark.scss\ and \light.scss\) in the \src/app/dev/DevToys.Blazor/Assets/sass/theme/linux\ directory. These stylesheets define a comprehensive set of CSS custom properties for colors, typography, control fills, strokes, and component states (such as buttons and checkboxes) to make the interface appear more native on Linux desktops, particularly Ubuntu.

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

Native macOS menu bar and window state persistence

The macOS desktop view now includes a native application menu bar with Edit commands (Cut, Copy, Paste, Select All) that interact with the embedded Blazor WebView, and the main window's position and size are automatically saved and restored upon reopening the app.

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

New Blazor UI styling foundation with reduced animations

The Blazor application's styling has been restructured into modular SCSS files (\_layout, \_transitions, \_typography, and the main devtoys.scss) to establish a consistent visual baseline. This includes a new layout system using a flexible mixin for alignment and spacing, standardized typography with disabled text selection, and a global reset for box-sizing and user interaction. Notably, the transition system now supports disabling animations via a data attribute, aligning with the goal to reduce visual motion in the interface.

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

New Blazor-based tool navigation and display pages

The application now uses Blazor for its main interface, introducing the ToolGroup page to display tools in a grid with a hero header and parallax scrolling effect, and the ToolPage to render individual tool interfaces. Users can now open tools in new windows, toggle favorites, and trigger hot reloads directly from the UI. The layout supports compact mode and reduced animations for performance, while the ToolGroup page includes a footer prompting users to suggest new tools if they are not found.

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

New JavaScript interop and utility extension methods

The application now includes new internal extension methods in the Core/Extensions area to improve JavaScript interop reliability and simplify UI value formatting. IJSRuntimeExtensions adds error-handling wrappers for JS invocations that catch JSException, JSDisconnectedException, and TaskCanceledException, preventing unhandled crashes during Blazor lifecycle events. JsonExtensions provides a PrepareJsInterop method that serializes objects while excluding null values, ensuring .NET nulls are treated as JavaScript undefined (particularly useful for Monaco Editor configuration). WebUnitsExtensions adds helper methods to convert numeric values to CSS pixel strings, percentage strings, and UISpacing enums to pixel integers.

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

New macOS dark and light theme styles added

The macOS visual appearance is now defined by dedicated Sass theme files for both dark and light modes. These styles introduce macOS-specific design tokens, including 6px control corner radii, specific text weights (300/400/600), and a blue accent palette, ensuring the application's UI components like buttons, cards, and checkboxes align with native macOS aesthetics.

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

New navigation, tool grouping, and smart detection logic in the main window

The application now features a new MainWindowViewModel that manages navigation history (allowing users to go back to previous selections), handles search queries, and checks for app and extension updates at startup. It integrates Smart Detection to automatically pass clipboard data to compatible tools when a user selects a new tool. Additionally, new view models (ToolGroupPageViewModel and ToolPageViewModel) introduce a hierarchical tool list that groups tools by category, recent usage, and favorites, and allows users to toggle favorite status for individual tools.

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

Splash screen and UI component styling added

The application now displays a centered splash screen on load, defined by new CSS rules in app.css. Additionally, the visual presentation of core UI elements—including buttons, checkboxes, radio buttons, toggle switches, data grids, dialogs, and the navigation sidebar—has been updated with new styles in devtoys.g.css to support themes, compact modes, and accessibility states.

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

Unified cross-platform theme system with native font stacks

The Blazor app now uses a centralized SCSS theme file that imports platform-specific styles for Windows, macOS, and Linux, applying them via data attributes. This change introduces a comprehensive font stack that prioritizes native system fonts for each OS (e.g., San Francisco on Mac, Segoe UI on Windows, and Ubuntu/Cantarell on Linux) to improve text appearance across different desktop environments. It also defines global font sizes, a consistent focus stroke for keyboard navigation, and disables transition animations for theme switching to ensure immediate visual updates.

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

Updated localization resources for the 'All Files' dialog string

The localization resources in the DevToys.Windows desktop app have been updated to include translations for the 'AllFiles' string (used in open file dialogs, e.g., 'All PNG, JPG, GIF') across multiple languages including Afrikaans, Arabic, Belarusian, Bengali, Catalan, Czech, Danish, German, and Greek. This ensures that users seeing file selection dialogs will now encounter properly localized text instead of the default English placeholder.

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

Updated main window localization strings

The localization resources for the main window have been updated to include new strings for the search interface (including placeholders, tooltips, and no-results messages), navigation controls, and update notifications for both the application and its extensions. Additionally, window title formats have been standardized to support dynamic tool names, and accessibility labels have been added for the tools list and favorites sections.

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

Windows desktop app now uses WPF Blazor with native window management

The Windows desktop client has been rebuilt to use WPF Blazor, replacing the previous WASDK/Uno implementation. This change introduces a native WPF window (MicaWindowWithOverlay) that hosts a Blazor WebView, enabling features like custom title bar integration, DPI awareness, and efficient window state persistence (position and size are now saved and restored). The app also includes native efficiency mode support, context menu handling, and improved rendering stability for the Blazor content.

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

Fixes

Fix WebView file provider for embedded assets

The WebView control now correctly serves Blazor content by combining the physical file system with embedded resources. This ensures that static assets packaged within the application assembly are accessible, resolving issues where embedded files were previously unavailable.

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

Updated application icons for macOS and Windows/Linux builds

The app icons for macOS (Preview and Stable) and Windows/Linux (Preview and Stable) have been updated with new SVG assets. These changes ensure the correct visual identity is displayed in the MSIX packages and on the desktop, resolving issues where icons were missing or incorrect in previous builds.

assets/logo · high confidence

Test coverage

Added mock implementations for unit testing infrastructure; Added mock tools and data detectors for unit testing; Added tests for extension installation security validation; Added unit test infrastructure for DevToys; Added unit tests for AppHelper, ExtensionOrderer, and OneOfParser; Added unit tests for Blazor Core utilities; Added unit tests for Blazor data type detectors; Added unit tests for GuiToolProvider and SmartDetectionService; Added unit tests for NavBarState logic; Added unit tests for UIElementWithChildren.GetChildElementById; Added unit tests for core API components.

Dependencies

Centralized dependency management and .NET 8 upgrade

The project now uses a central package management file (Directory.Packages.props) to define versions for all NuGet packages, ensuring consistency across the solution. This change includes an upgrade to .NET 8.0.0 and updates key libraries such as CommunityToolkit to 8.3.2, xUnit to 2.5.0, and SixLabors.ImageSharp to 3.1.12. Additionally, the build system now relies on Nuke.Common 8.0.0 for build automation.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 42 → 41 (-0.6)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 58 → 58 (+0.1)
  • Architecture 72 → 62 (-10.1)
  • Maturity 46 → 50 (+4.1)
  • Readiness 35 → 35 (+0.0)
  • Security 85 → 92 (+7.6)
  • Accessibility 38 → 35 (-2.4)
  • Performance 70 → 60 (-9.7)

Resolved (15)

  • Low cohesion: GuiToolProvider (LCOM4 4) (src/app/dev/DevToys.Core/Tools/GuiToolProvider.cs)
  • Projects may be oversized for their cohesion
  • Scanner failed to run — not a clean result
  • Scanner failed to run — not a clean result
  • XML-doc coverage: DevToys.Api (src/app/dev/DevToys.Api/DevToys.Api.csproj)
  • XML-doc coverage: DevToys.Blazor (src/app/dev/DevToys.Blazor/DevToys.Blazor.csproj)
  • XML-doc coverage: DevToys.Business (src/app/dev/DevToys.Business/DevToys.Business.csproj)
  • XML-doc coverage: DevToys.CLI (src/app/dev/platforms/desktop/DevToys.CLI/DevToys.CLI.csproj)
  • XML-doc coverage: DevToys.Core (src/app/dev/DevToys.Core/DevToys.Core.csproj)
  • XML-doc coverage: DevToys.Linux (src/app/dev/platforms/desktop/DevToys.Linux/DevToys.Linux.csproj)
  • XML-doc coverage: DevToys.Localization (src/app/dev/DevToys.Localization/DevToys.Localization.csproj)
  • XML-doc coverage: DevToys.MacOS (src/app/dev/platforms/desktop/DevToys.MacOS/DevToys.MacOS.csproj)
  • XML-doc coverage: DevToys.Windows (src/app/dev/platforms/desktop/DevToys.Windows/DevToys.Windows.csproj)
  • XML-doc coverage: ResxHelperGenerator (src/generators/ResxHelperGenerator/ResxHelperGenerator.csproj)
  • XML-doc coverage: _build (src/build/_build.csproj)

New (39)

  • Projects may be oversized for their cohesion (src/app/dev/DevToys.Blazor/DevToys.Blazor.csproj)
  • doc comments repeat the names (src/app/dev/DevToys.Api/Core/OneOfExtensions.cs)
  • doc comments repeat the names (src/app/dev/DevToys.Blazor/Components/Text/MonacoEditor/Monaco/Editor/ComputedEditorOptions.cs)
  • doc comments repeat the names (src/app/dev/DevToys.Blazor/wwwroot/js/simplebar-modified.js)
  • doc comments repeat the names (src/app/dev/DevToys.Core/AppHelper.cs)
  • doc comments repeat the names (src/app/dev/platforms/desktop/DevToys.Windows/Core/Helpers/DpiHelper.cs)
  • redundant comment (src/app/dev/DevToys.Blazor/Assets/javascript/dom.ts)
  • redundant comment (src/app/dev/DevToys.Blazor/BuiltInTools/ExtensionsManager/ExtensionsManagerGuiTool.cs)
  • redundant comment (src/app/dev/DevToys.Blazor/BuiltInTools/ExtensionsManager/ExtensionsManagerGuiTool.cs)
  • redundant comment (src/app/dev/DevToys.Blazor/BuiltInTools/Settings/SettingsGuiTool.cs)
  • redundant comment (src/app/dev/DevToys.Blazor/BuiltInTools/Settings/SettingsGuiTool.cs)
  • redundant comment (src/app/dev/DevToys.Blazor/Components/Collections/GridView/GridView.razor.ts)
  • redundant comment (src/app/dev/DevToys.Blazor/Components/Menu/NavBar/NavBar.razor.ts)
  • redundant comment (src/app/dev/DevToys.Blazor/Components/UIElements/UIDiffTextInputPresenter.razor.cs)
  • redundant comment (src/app/dev/DevToys.Blazor/Components/UIElements/UIMultiLineTextInputPresenter.razor.cs)
  • redundant comment (src/app/dev/DevToys.Blazor/Components/UIElements/UIMultiLineTextInputPresenter.razor.cs)
  • redundant comment (src/app/dev/DevToys.Blazor/Core/Services/MonacoLanguageService.cs)
  • redundant comment (src/app/dev/DevToys.Blazor/Pages/Index.razor.cs)
  • redundant comment (src/app/dev/DevToys.Blazor/Pages/Index.razor.cs)
  • redundant comment (src/app/dev/DevToys.Business/ViewModels/ToolGroupPageViewModel.cs)
  • …and 19 more

Architecture

  • Unchanged — 3 containers · 0 contexts · 0 edges

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 10 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 2dbbc8aa594978d11165a0e8112243c96a277dbc — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.4+preprod-464a0040a931.