Devolutions/UniGetUI

UniGetUI is a cross-platform desktop application that provides a unified graphical interface for managing software packages across multiple package managers, including WinGet, Chocolatey, Scoop, and various Linux, Rust, and .NET tools. The system features a modern Avalonia-based UI, supports headless automation via a CLI and IPC API, and handles package operations such as installation, updates, and dependency resolution. It also includes robust features for localization, telemetry, and secure settings management.

61 changes.

The project underwent a significant architectural refactoring, separating core logic, settings, and data management into distinct modules while introducing a new, unified package manager interface. This period also saw the addition of support for numerous new package managers, including Bun, Cargo, NPM, Pip, and PowerShell 7, alongside comprehensive unit testing for the new infrastructure.

45 changes.

The project underwent a major architectural shift by porting the desktop user interface to the cross-platform Avalonia framework, enabling support for macOS and Linux alongside Windows. This period also introduced a new telemetry system, expanded package manager support for Linux and Windows ecosystems, and established a secure settings framework for privileged operations.

Users can now manage .NET tools via the new DotNet package manager. This adds support for installing, updating, and listing .NET tools from NuGet, with capabilities for custom scopes, architectures, and proxy settings. The implementation includes parsing installed packages and handling executable paths for both Windows and Unix-like systems.

src/UniGetUI.PackageEngine.Managers.Dotnet · high confidence

The file picker library now includes .NET Runtime Callable Wrapper (RCW) classes for the Windows Shell File Open and File Save dialogs, along with a helper class that implements the actual dialog interaction. This enables the application to invoke native Windows file picker dialogs from .NET code, allowing users to select files or folders and save files with proper extension handling.

src/ExternalLibraries.FilePickers/Classes · high confidence

The About, Contributors, Third-party licenses, and Translators pages are now available in the Avalonia-based interface. Users can view the application's about information, browse a list of contributors with their GitHub profiles, review third-party licenses, and see a list of translators with an option to become one.

src/UniGetUI.Avalonia/Views/Pages/AboutPages · high confidence

Users can now manage Rust packages via the Cargo package manager. This feature allows searching for, installing, updating, and uninstalling Rust libraries and programs. The implementation integrates with the Crates.io registry, utilizing cargo-binstall for binary installation and cargo-update for update checks, with specific handling for binary-only packages and version detection.

src/UniGetUI.PackageEngine.Managers.Cargo · high confidence

The package now includes the necessary Chocolatey metadata and scripts to support installation and uninstallation of UniGetUI via the Chocolatey package manager. This adds the nuspec file defining package metadata and the PowerShell scripts (install, uninstall, and deploy) that handle the silent installation and cleanup of the application on Windows systems.

package · high confidence

The Avalonia port now includes dedicated view models for the Help and Release Notes pages. The Help page now opens the GitHub repository URL, while the Release Notes page links to the official release notes. Both pages support opening the respective URLs in an external browser.

src/UniGetUI.Avalonia/ViewModels/Pages · high confidence

New HelpPage and ReleaseNotesPage views are introduced for the Avalonia implementation, each featuring a toolbar with navigation buttons, a progress indicator, and an embedded WebView. On Windows, the pages load the respective web content; on Linux, a fallback message prompts the user to open the content in an external browser. Both pages implement IDisposable to properly release the WebView2 resources when the user navigates away, preventing memory leaks.

src/UniGetUI.Avalonia/Views/Pages · high confidence

Users will see localized text in the UI, as the new TranslateExtension markup extension enables string translation at load time via the {t:Translate} XAML syntax.

src/UniGetUI.Avalonia/MarkupExtensions · high confidence

The file picker library now includes internal enumerations for Windows Shell Object Model constants, including FOS (File Open Dialog options), FDE\_OVERWRITE\_RESPONSE, FDE\_SHAREVIOLation\_RESPONSE, FDAP, SIATTRIBFLAGS, SIGDN, and HRESULT values. These definitions support the underlying file picker implementation by providing the necessary constants for Windows API interactions.

src/ExternalLibraries.FilePickers/Enums · high confidence

A new Windows-specific implementation for clipboard access has been added to the ExternalLibraries.Clipboard project. This introduces a \WindowsClipboard\ class that wraps Win32 API calls (via P/Invoke) to read and write text to the system clipboard, providing the underlying mechanism for clipboard operations on Windows platforms.

src/ExternalLibraries.Clipboard · high confidence

The settings UI now uses a new set of Avalonia-based controls (ButtonCard, CheckboxButtonCard, CheckboxCard, ComboboxCard, SecureCheckboxCard, SettingsCard, SettingsPageButton, TextboxCard, and TranslatedTextBlock) to render settings pages. These components provide the underlying UI for configuration options, including toggle switches, text inputs, and dropdowns, with support for accessibility announcements and command bindings.

src/UniGetUI.Avalonia/Views/Controls/Settings · high confidence

Users can now manage JavaScript packages using the Bun runtime. This change introduces a new package manager integration that supports searching for packages via the npm registry, listing installed and available updates, and performing install, update, and uninstall operations. The implementation handles both global and local package scopes, retrieving detailed package information such as license, description, and dependencies from the npm registry.

(repo-wide) · high confidence

The application now displays the user's GitHub avatar and name in the UI, along with login/logout functionality. This change introduces a new \UserAvatarViewModel\ that manages the lifecycle of the user's authentication state, fetching the user's display name and avatar image from GitHub, and handling the disposal of resources to prevent memory leaks.

src/UniGetUI.Avalonia/ViewModels/Controls · high confidence

Introduced DotNetDetailsHelper and DotNetPkgOperationHelper to manage .NET Tools interactions. The new DotNetDetailsHelper defines the default installation location for .NET tools as the user's home directory under .dotnet/tools. The DotNetPkgOperationHelper constructs command-line arguments for install, update, and uninstall operations, supporting global scope, architecture selection, version pinning, and custom parameters. It also handles operation results, automatically retrying as global if a local installation fails.

src/UniGetUI.PackageEngine.Managers.Dotnet/Helpers · medium confidence

Added C\# interface definitions for the Windows Shell IFileDialog, IFileOpenDialog, and IFileSaveDialog COM objects, along with supporting interfaces (IModalWindow, IShellItem, IShellItemArray, and IFileDialogEvents). These changes enable the application to interact with native Windows file picker dialogs through managed code.

src/ExternalLibraries.FilePickers/Interfaces · high confidence

The new IpcTransport.cs file introduces the core configuration for the IPC API, supporting both TCP and Named Pipe transports. It defines the transport options, including default ports and pipe names, and implements logic to load, persist, and order IPC endpoint registrations for both GUI and headless CLI sessions.

UniGetUI.Interface.IpcApi · high confidence

Users can now generate an MSI installer package for UniGetUI by following the new instructions in the MsiCreator directory. This includes a Visual Studio solution and project file that wrap the standard installer, allowing deployment via Group Policy or other MSI-based distribution methods. The accompanying README provides step-by-step instructions for building the MSI, noting that dependencies like the Visual C++ Redistributable and Edge WebView Runtime must be installed separately.

InstallerExtras/MsiCreator · high confidence

New helper classes (VcpkgPkgDetailsHelper, VcpkgPkgOperationHelper, VcpkgSourceHelper) were added to the Vcpkg manager to support fetching package metadata, executing install/update/uninstall operations, and managing sources. This enables the application to retrieve Vcpkg package details (such as description, license, and dependencies) and perform package management actions through the unified interface.

src/UniGetUI.PackageEngine.Managers.Vcpkg/Helpers · high confidence

The \src/ExternalLibraries.FilePickers\ location now contains the concrete implementations for file and folder selection dialogs. This includes \FileOpenPicker\ and \FileSavePicker\ classes that wrap the underlying \Helper\ methods to present open and save dialogs, as well as a \FolderPicker\ for directory selection. The directory also includes supporting structures (\COMDLG\_FILTERSPEC\, \PROPERTYKEY\) and GUID constants (\CLSIDGuid\, \IIDGuid\, \KFIDGuid\) required for the picker functionality.

src/ExternalLibraries.FilePickers · medium confidence

Users on Linux distributions based on Debian/Ubuntu, RHEL/Fedora, and Arch Linux can now manage packages using the native APT, DNF, and Pacman package managers respectively. This includes full support for searching, installing, updating, and removing packages, as well as viewing detailed package information and dependencies through the UniGetUI interface.

src/UniGetUI.PackageEngine.Managers.Apt, src/UniGetUI.PackageEngine.Managers.Dnf, src/UniGetUI.PackageEngine.Managers.Pacman · high confidence

The change adds four new model files to the Avalonia UI layer: PackageWrapper, which manages package data and icon caching for the package list; PackageRowModel, a lightweight row model for package lists with lazy icon loading and primary action handling; PackagePageMode, an enum defining the current page context (Discover, Updates, Installed); and ShellPageType, an enum defining the available shell pages. These models support the cross-platform Avalonia port by providing the necessary data structures and state management for the UI layer.

src/UniGetUI.Avalonia/Models · high confidence

The Avalonia port introduces new viewmodels for the 'Install Options' dialog (including version, architecture, scope, CLI arguments, and pre/post-install commands), the 'Operation' progress dialog (showing status, badges, and live output), the 'Package Details' dialog (showing description, dependencies, and installer info), the 'Manage Desktop Shortcuts' dialog, and the 'Manage Ignored Updates' dialog. These viewmodels implement the UI logic for these specific dialog pages, mirroring the WinUI feature set within the new Avalonia framework.

src/UniGetUI.Avalonia/ViewModels/DialogPages · high confidence

The settings pages in the application have been ported to the new Avalonia UI framework. This change introduces new view models for each settings category (such as General, Interface, Notifications, Updates, and more) to manage the state and logic for the settings UI. This port is part of the broader effort to migrate the application's user interface to Avalonia, which will eventually replace the existing WinUI-based interface.

src/UniGetUI.Avalonia/ViewModels/Pages/SettingsPages · high confidence

The Software pages (Discover, Installed, Updates, Bundles) have been ported from the previous WinUI implementation to the new Avalonia-based UI framework. This includes the base \AbstractPackagesPage\ layout, styling, and code-behind, as well as the specific implementations for each page type, providing feature parity with the existing WinUI version.

src/UniGetUI.Avalonia/Views/SoftwarePages · high confidence

The SoftwarePages area now includes a new PackagesPageViewModel that implements the core logic for the package list, including search modes, view modes, and source tree nodes. This change introduces the foundational ViewModel for the Avalonia UI, enabling features like filter pane width tracking, package sorting, and state management for the package list.

src/UniGetUI.Avalonia/ViewModels/SoftwarePages · high confidence

The Cargo package manager is now supported in UniGetUI, enabling users to install, update, and uninstall Rust/Cargo packages directly through the UI. The implementation includes a new helper class to fetch package details from Crates.io and another to manage package operations. A key feature is the automatic detection and use of 'cargo-binstall' for faster, pre-compiled binary installations when available, falling back to standard cargo install otherwise. This allows for quicker updates and installations compared to traditional source compilation.

src/UniGetUI.PackageEngine.Managers.Cargo/Helpers · high confidence

The application's UI layer has been migrated to the Avalonia framework. This change introduces new view models that manage the main window's navigation state, the sidebar's layout modes (dock, rail, and overlay), and the About page's content (version, contributors, translators, and third-party licenses). Users will experience the updated interface as the application now uses Avalonia for its graphical user interface, which includes a more responsive sidebar and consistent styling across the application.

src/UniGetUI.Avalonia/ViewModels · high confidence

The application now features a new cross-platform desktop UI built on the Avalonia framework, replacing the previous WinUI/WinAppSDK-based implementation. This change brings the desktop experience to macOS and Linux, while also introducing a splash screen on startup, Windows 11 Mica backdrop styling, and improved crash reporting via Devolutions Cloud. The update also includes a shared command-line interface for settings and auto-updater helpers, ensuring consistent behavior across all supported platforms.

src/UniGetUI.Avalonia · high confidence

The application now supports managing Python packages via pip. This includes discovering available packages from PyPI, fetching version details, and handling proxy settings for pip operations. The implementation includes caching of the PyPI index and parallel fetching of package information.

src/UniGetUI.PackageEngine.Managers.Pip · high confidence

Added a new SecureSettings module that provides a key-based configuration system for controlling privileged operations, including the ability to force user-level gsudo execution and block CLI parameters if they have not been enabled. The update also introduces a SecureGHTokenManager for securely storing, retrieving, and deleting GitHub access tokens using the system's credential store.

src/UniGetUI.Core.SecureSettings · high confidence

Adds core Avalonia infrastructure components, including an accessibility announcement service for screen readers, an async command implementation for the UI, and a single-instance mutex/file-lock mechanism to prevent duplicate app instances. The update also introduces a new AppRestartHelper for managing application restarts and an operation registry to track and display package management status in the UI.

src/UniGetUI.Avalonia/Infrastructure · high confidence

The core library now includes several new classes to improve performance and data handling. A new \TaskRecycler\ class provides static methods to cache the results of CPU-intensive or concurrent method calls, allowing the application to reuse previous results for a specified duration. Additionally, a \SortableObservableCollection\ has been added to automatically maintain index values for list items when the collection changes, and an \ObservableQueue\ has been introduced to expose events for queue operations. These changes support more efficient data management and UI updates within the application.

src/UniGetUI.Core.Classes · high confidence

The NPM package manager is now supported in the application, allowing users to search for, install, update, and manage Node.js packages. The implementation uses JSON output for parsing results and supports both local and global package scopes.

src/UniGetUI.PackageEngine.Managers.Npm · high confidence

New MSBuild publish profile XML files have been added for Win, Linux, and macOS on both x64 and arm64 architectures. Each profile configures the build to produce a self-contained, fully trimmed, NativeAOT-compiled binary. This enables the application to be published as a native executable, which can improve startup time and reduce memory footprint, though it may increase the initial download size.

src/UniGetUI.Avalonia/Properties · high confidence

The application now exposes a comprehensive IPC API and CLI interface, allowing external processes to manage the application headlessly or via command line. Users and scripts can now perform operations such as listing and managing packages, performing local and cloud (GitHub Gist) backups, managing desktop shortcuts, and controlling the application state (show, navigate, quit) without a graphical interface. This enables automation of package management tasks and integration with external tools.

src/UniGetUI.Interface.IpcApi · high confidence

A new ScaleClampConverter has been added to the Avalonia UI layer. This converter allows UI elements to scale down proportionally with their container while enforcing a maximum size limit, preventing elements from growing beyond a sensible upper bound. It accepts a parameter in the format "fraction\|max" to define the scaling behavior.

src/UniGetUI.Avalonia/Converters · high confidence

Added four new configuration files in the WinGet directory that define different installation profiles for UniGetUI. The 'unigetui-min' profile installs only the essential runtime dependencies (WebView2, VC++ Redistributable, and UniGetUI itself). The 'unigetui-all' profile expands on the minimum by also installing package managers (Chocolatey, Python, PowerShell 7, NodeJS, Rust) and the .NET 10 SDK. A 'develop-unigetui' profile is also provided, which includes all tools from the 'all' profile plus development tools like Git, Visual Studio 2022, Windows SDKs, and Inno Setup. A documentation file 'configurations.md' explains the differences between these profiles.

configuration.winget · high confidence

Added a suite of PowerShell scripts to the \scripts/\ directory to automate the build, packaging, and release process. \build.ps1\ orchestrates the .NET publish and Inno Setup installer generation. \publish-nativeaot.ps1\ handles NativeAOT self-contained Windows builds. \build-chocolatey-package.ps1\ creates Chocolatey \.nupkg\ packages. \package-linux.ps1\ generates \.deb\ and \.rpm\ packages for Linux. \sign.ps1\ manages code-signing via Azure Key Vault. Supporting scripts include \set-version.ps1\ for version stamping, \generate-integrity-tree.ps1\ and \verify-integrity-tree.ps1\ for file integrity validation, \merge-publish-output.ps1\ for directory merging, and \update-icons.ps1\ for icon database maintenance. A \BuildNumber\ file is also added to track build counts.

scripts · high confidence

The application now uses new internal classes to manage core data and configuration. A dedicated credential store (CoreCredentialStore) provides cross-platform secure storage for secrets, using the Windows PasswordVault on Windows and encrypted file storage on other platforms. The CoreData class now defines versioning, user data directories, and release URL logic, while UpdateInProgressGuard prevents crashes during partial in-place updates by detecting active installers. Contributors and license metadata are also centralized in new static classes.

src/UniGetUI.Core.Data · high confidence

The Avalonia interface gains several new dialog windows: an About window with tabs for licenses, contributors, and translators; a crash report dialog that sends error details to Devolutions; a confirmation dialog to discard unsaved bundle changes; an integrity violation warning; a window to manage desktop shortcuts; a list to manage ignored updates; and a detailed options panel for installing or updating packages. These views implement the core user interactions for these features within the new UI framework.

src/UniGetUI.Avalonia/Views/DialogPages · high confidence

Added new helper classes to the package manager infrastructure: ArpRegistryHelper resolves Windows install locations via the registry; BasePkgDetailsHelper, BasePkgOperationHelper, and BaseSourceHelper provide abstract base implementations for fetching package details, executing operations, and managing sources. These changes introduce a more structured, manager-agnostic way to handle package metadata, icons, screenshots, and source management across different package managers.

src/UniGetUI.PackageEngine.PackageManagerClasses/Manager/Helpers · medium confidence

The package manager engine now includes new classes for structured logging and source management. ManagerLogger and its associated TaskLogger classes provide a way to track and retain recent operations, with a cap on retained operations and lines to manage memory. ManagerSource and SourceFactory classes manage package manager sources, including caching and URL replacement. A NullPackageManager class provides a dummy implementation for testing or fallback scenarios.

src/UniGetUI.PackageEngine.PackageManagerClasses/Manager/Classes · medium confidence

The package engine now uses a dedicated \UniGetUI.PackageEngine.Enums\ project containing new types that define core behaviors and states. \PackageScope\ and \Architecture\ provide standardized string constants for installation scope and CPU architecture. \OperationVeredict\ and \OperationStatus\ define the outcomes and states of background operations. \LoggableTaskType\ enumerates the specific tasks the engine can perform (e.g., \FindPackages\, \ListUpdates\). \ManagerCapabilities\ introduces a \ManagerCapabilities\ struct and \ProxySupport\/\PackageReleaseDateSupport\ enums to track each package manager's supported features, such as proxy support, admin requirements, and custom scope/architecture handling. \OverridenInstallationOptions\ allows specific package managers to override default installation parameters.

src/UniGetUI.PackageEngine.Enums · high confidence

The package engine's interface layer has been expanded with new contracts for logging (\IManagerLogger\, \ITaskLogger\), source management (\IManagerSource\, \ISourceFactory\), and package metadata (\IPackageDetails\). These additions provide a structured way to handle CLI output encoding, manage multiple package manager sources, and retrieve detailed package information such as descriptions, authors, and dependencies. The \IPackageManager\ interface now exposes helpers for multi-source operations, package details, and operations, standardizing how the UI interacts with different package managers.

src/UniGetUI.PackageEngine.Interfaces · high confidence

Added PipPkgDetailsHelper and PipPkgOperationHelper classes to handle fetching package metadata from the PyPI API and managing pip install/update/uninstall operations. The new helpers implement logic for parsing package details (description, author, license, dependencies, versions) and constructing command-line arguments, including support for user-scoped installs, pre-release versions, and breaking system package restrictions.

src/UniGetUI.PackageEngine.Managers.Pip/Helpers · high confidence

The settings interface has been restructured into dedicated pages within the Avalonia UI. Users can now configure administrator elevation options (including delegation to the Devolutions Agent broker) on the Administrator page, manage local and cloud package backups on the Backup page, and adjust general preferences such as language, auto-updates, and privacy settings on the General page. These new pages also include an interface for managing install options like architecture, scope, and custom CLI arguments.

src/UniGetUI.Avalonia/Views/Pages/SettingsPages · high confidence

Added new SVG assets for the application's splash screen, including both light and dark theme variants, along with new symbol icons for 'DiscoverPackage' and 'Filter', and a generated icon font with its associated demo files.

src/SharedAssets · high confidence

The application now sends telemetry data to a new backend, Devolutions OpenSearch, replacing the previous implementation. This change introduces a new \TelemetryHandler\ and associated event classes (e.g., \TelemetryEventBase\, \UniGetUIActivityEvent\) that collect and transmit usage statistics, including active settings, enabled package managers, and platform information. The system is configured with specific OpenSearch credentials and index names, and it gracefully disables telemetry if credentials are missing or the user has opted out.

src/UniGetUI.Interface.Telemetry · high confidence

The scripts/translation directory now includes a comprehensive set of PowerShell scripts to manage translation workflows. This includes helper modules (LanguageData, TranslationJsonTools, TranslationSourceTools) and specific tools for exporting key diffs, aligning translation boundaries, checking translation status, merging diff batches, and synchronizing metadata. These scripts enable automated validation of translation completeness, synchronization of language files with source code, and generation of reports on translation progress and discrepancies.

scripts/translation · high confidence

The \.agents\ directory now includes a complete, agent-facing workflow for managing translation patches rather than full language files. The new skills—\translation-diff-export\, \translation-diff-import\, \translation-diff-translate\, \translation-review\, \translation-source-sync\, and \translation-status\—provide scripts and documentation to extract untranslated or changed strings, generate sparse patches for translators, merge completed translations back into full language files, and audit translation quality. This replaces the previous approach of handling entire locale files, enabling more efficient, targeted updates to the \src/Languages\ directory.

.agents · high confidence

The PowerShell 7 package manager is now implemented, allowing users to find, install, and manage PowerShell modules, scripts, and cmdlets from PSGallery and other sources. The implementation uses the PSResourceGet cmdlets, supports both user and machine installation scopes, and includes capabilities for downloading installers and listing dependencies.

src/UniGetUI.PackageEngine.Managers.PowerShell7 · high confidence

Added support for the PowerShell 7 package manager, introducing new helper classes to manage package operations, source repositories, and installation details. This enables users to install, update, and uninstall PowerShell modules via the UI, with support for specifying versions, scopes, and custom parameters.

src/UniGetUI.PackageEngine.Managers.PowerShell7/Helpers · high confidence

Added standard project documentation and configuration files, including .deepsource.toml for static analysis, .gitattributes and .gitignore for repository management, and markdown files (AGENTS.md, CLAUDE.md, CODE\_OF\_CONDUCT.md, CONTRIBUTING.md) that define coding standards, contribution guidelines, and community expectations for the UniGetUI project.

(repo-wide) · high confidence

The project's build system has been centralized with a new \Directory.Build.props\ file that defines shared properties such as the .NET 10 target framework, nullable references, and optimization settings. Additionally, a new \BrokerRequestBuilder\ component was added to map local package operations to the Devolutions Agent broker protocol, enabling the application to fail package operations when the agent is unavailable rather than silently falling back to local execution.

src · high confidence

The Avalonia UI now supports Windows 11 Mica transparency effects, allowing the window and page surfaces to become translucent so the Mica backdrop shows through. This is achieved by introducing new style resources in \Styles.Common.axaml\ that map WinUI Fluent v2 design tokens (accent fills, text colors, menu surfaces, status banners) and in \Styles.WindowsMica.axaml\ which overrides specific background and border brushes to be transparent or semi-transparent when Mica is active. This change aligns the Avalonia interface with WinUI styling and behavior, ensuring consistent visual feedback across the application.

src/UniGetUI.Avalonia/Assets/Styles · high confidence

Added a new macOS native notification bridge (UniGetUIMacNotificationBridge.m) that enables push notifications and handles activation callbacks on macOS. Additionally, the macOS app bundle now includes a new SVG-based app icon (devolutions-unigetui-icon-fullbleed.svg) and associated icon configuration (icon.json) for proper display in the macOS 26 appearance styling, along with updated entitlements and Info.plist configurations for macOS builds.

scripts/macos · high confidence

The codebase has been restructured to separate core logic from the UI and package manager implementations. New projects have been created for core components (Classes, Data, IconEngine, LanguageEngine, Logger, Settings, Tools, SecureSettings) and their corresponding test projects. Additionally, package manager implementations (Apt, Bun, Cargo, Chocolatey, Dnf, Dotnet, Flatpak, Generic.NuGet) have been moved into their own dedicated projects. This separation isolates the package engine and core utilities from the UI layer, improving modularity and testability.

(dependencies) · high confidence

The WinGet manager's logic for retrieving package details, handling operations, and managing sources has been reorganized into new helper classes (WinGetPkgDetailsHelper, WinGetPkgOperationHelper, and WinGetSourceHelper). This change improves how the application fetches package metadata, constructs command-line arguments for install/update/uninstall actions, and manages WinGet sources, providing a more structured and maintainable foundation for WinGet interactions.

src/UniGetUI.PackageEngine.Managers.WinGet/Helpers · high confidence

Users can now manage Snap packages on Linux. The update introduces the Snap package manager integration, including the main manager class (Snap.cs) and helper classes for parsing package details (SnapPkgDetailsHelper.cs), handling operations like install/uninstall (SnapPkgOperationHelper.cs), and parsing Snap command-line output (SnapParsing.cs).

src/UniGetUI.PackageEngine.Managers.Snap · medium confidence

A new symlink at .claude/skills pointing to ../.agents/skills has been added, enabling compatibility with Claude Code's expected directory structure.

.claude · low confidence

The Avalonia UI layer introduces several behavioral improvements and new controls. DataGrid scrolling is now animated with a smooth glide effect, improving the user experience during list interactions. SVG icon rendering is optimized with a static cache to prevent re-parsing assets on every scroll or render cycle, reducing memory pressure and improving performance. A new InfoBar control provides animated toast notifications with severity-based styling and accessibility support. The LogTextEditor control now supports per-line coloring, hyperlink theming, and prevents auto-scroll from fighting manual scrolling. Additionally, a UserAvatarControl manages login state and a WebView control configures user data folders.

src/UniGetUI.Avalonia/Views/Controls · high confidence

The main window, sidebar, and splash screen have been rewritten in Avalonia to align with WinUI styling and behavior. This brings a new visual design including a sliding navigation pill animation, WinUI-style title bar buttons, and entrance page transitions. The splash screen now supports dark/light theme variants. These changes improve the visual consistency and responsiveness of the application's primary interface.

src/UniGetUI.Avalonia/Views · high confidence

The application now uses a centralized \IconType\ enum to map package managers (such as Apt, Dnf, Pacman, Snap, Flatpak, and Bun) and UI states to specific font glyphs. This replaces previous string-based icon loading, ensuring consistent visual representation across the interface. Additionally, new \PackageTag\ and \NotificationArguments\ enums standardize package status indicators and notification triggers.

src/UniGetUI.Interface.Enums · medium confidence

The package engine now uses a new PEInterface class to manage the initialization of all supported package managers (including Bun, Cargo, Flatpak, and Linux-specific managers like Apt and Dnf). This change consolidates manager loading and introduces fault tolerance: if a specific package manager fails to initialize, the system logs the error but continues to function with the remaining managers, preventing a single failure from crashing the application.

src/UniGetUI.PackageEngine.PackageEngine · medium confidence

The package management layer has been completely refactored around a new \AbstractOperation\ base class, introducing a structured, event-driven execution model. This change brings several key improvements: operations now support pre- and post-conditions (allowing, for example, an uninstall to complete before an update starts), parallel execution limits are enforced via a new queue system, and all operation logs are now structured into \OperationHistoryRecord\ objects for better persistence and UI display. Additionally, the system now supports routing specific package managers through the Devolutions Agent broker, handles process termination more robustly, and provides a richer, more reliable cancellation and retry experience for users.

src/UniGetUI.PackageEngine.Operations · high confidence

A new pre-commit hook has been added to automatically run 'dotnet format' on staged C\# and related project files. The hook ensures that only staged changes are formatted, preventing mixed-content issues, and will stage any formatting updates automatically, requiring the user to re-commit after reviewing the changes.

.githooks · high confidence

The application now verifies file integrity using SHA256 hashes instead of the previous MD5, providing stronger protection against corrupted or tampered files. Additionally, the app now suspends the DWM and XAML threads when the application is in the background to optimize CPU usage, and improves error reporting by including integrity check results in crash details.

src/UniGetUI.Core.Tools · high confidence

The WindowsPackageManager.Interop layer now introduces a dedicated exception type, WinGetComActivationException, which captures the CLSID, IID, and HRESULT of failed COM activations. This allows callers to distinguish between expected fallback conditions (such as 'Class not registered' or 'Element not found') and unexpected errors. Additionally, the COM activation logic now supports a lower-trust registration context, enabling WinGet to activate COM objects successfully even when the application is running with elevated privileges, preventing the previous crash (0xC0000005) in admin contexts.

src/WindowsPackageManager.Interop · high confidence

The language engine now loads bundled language files and resolves locale identifiers more robustly. It maps locale aliases (e.g., 'ua' to 'uk' for Ukrainian) and handles locale variations (hyphens vs. underscores) to ensure the correct language file is loaded. The system also gracefully handles missing or malformed language files by falling back to English, preventing crashes and ensuring the application remains functional even if a specific language file is absent or corrupted.

src/UniGetUI.Core.LanguageEngine · high confidence

The installer now offers a 'portable' installation option, allowing users to run UniGetUI without a full system installation. Additionally, the installer has been refactored to use the InnoDependencyInstaller framework for managing runtime dependencies, replacing the previous bundled Chocolatey CLI approach. This change also includes updated translations for the installer interface across multiple languages.

InstallerExtras · high confidence

Added BaseNuGet and BaseNuGetDetailsHelper classes to provide a shared implementation for NuGet-based package managers. This refactoring consolidates common logic for fetching package data, parsing manifests, and handling search queries, allowing specific managers (like PowerShell) to inherit this behavior. The change also exposes internal members to the test assembly to support unit testing of these new base classes.

src/UniGetUI.PackageEngine.Managers.Generic.NuGet · high confidence

The package engine now uses a new abstract \PackageManager\ base class that standardizes how package managers are initialized and validated. This class enforces that all managers implement specific helper interfaces (such as \IPackageOperationHelper\ and \IPackageDetailsHelper\) and provides a structured \Initialize\ method that verifies the manager's executable, version, and configuration before marking it as ready. This change ensures that disabled or missing package managers are handled consistently, and that managers without required dependencies or valid configurations are gracefully reported as not found rather than crashing.

src/UniGetUI.PackageEngine.PackageManagerClasses/Manager · high confidence

The application's settings storage has been refactored to use a new \SettingsEngine\ that persists boolean, value, list, and dictionary settings as individual files in the user configuration directory. Boolean and value settings are stored as empty or text files, while complex list and dictionary settings are saved as \.json\ files. This change introduces a caching layer using \ConcurrentDictionary\ for improved performance and thread safety, and updates the import/export functionality to work with the new file structure.

src/UniGetUI.Core.Settings · high confidence

The NPM package manager integration has been refactored to properly handle NPM aliases (e.g., 'eslint-v9': 'npm:eslint@^9.x') and scoped packages. The new \NpmPkgDetailsHelper\ and \NpmPkgOperationHelper\ classes parse package metadata and construct installation commands that correctly resolve aliased dependencies and handle Windows shell quoting. This ensures that operations like update, install, and uninstall work correctly for packages with aliases or special characters in their identifiers.

src/UniGetUI.PackageEngine.Managers.Npm/Helpers · medium confidence

The PowerShell package manager integration now uses dedicated helper classes (PowerShellDetailsHelper, PowerShellPkgOperationHelper, and PowerShellSourceHelper) to handle installation, updates, and source management. These changes improve the reliability of PowerShell module operations, including proper disposal of process instances, correct handling of installation scopes, and robust parsing of repository sources.

src/UniGetUI.PackageEngine.Managers.PowerShell/Helpers · medium confidence

The application now uses a new \UniGetUI.Core.Logger\ module to manage log entries and session logs. A key privacy feature is the ability to redact the current user's name from all logged lines, which can be enabled via the \RedactUsername\ setting to protect user identity in debug output and session logs.

src/UniGetUI.Core.Logger · high confidence

A new \DesktopShortcutsDatabase\ class has been introduced to track which desktop shortcuts are deletable, allowing the application to remember user preferences about keeping or removing shortcuts. The \IgnoredUpdatesDatabase\ has been refactored to include a \PauseTime\ class for managing temporary update ignores. Additionally, \InstallOptionsFactory\ now uses a new \InstallOptions\ class with JSON serialization for per-package and per-manager settings, and \PackageDetails\ now stores the installer size as a \long\ instead of a \double\.

src/UniGetUI.PackageEngine.PackageManagerClasses/Packages/Classes · high confidence

The application now uses a dedicated icon caching system that stores and validates downloaded icons and screenshots. This system supports multiple validation methods (SHA256, file size, package version, and URI source) to ensure cached assets are valid and up-to-date. It also manages a local database of package icons and screenshots, which is periodically refreshed from a remote source. This change improves the reliability of icon display and reduces unnecessary network requests by caching assets locally.

src/UniGetUI.Core.IconStore · high confidence

The LogPages area now includes new view models that power a structured operation history list (with filtering by status, kind, and manager) and dedicated log pages for each package manager and the application itself. Users can now view, filter, and sort past operations, and access detailed logs with severity-based color coding that adapts to the current dark or light theme.

src/UniGetUI.Avalonia/ViewModels/Pages/LogPages · high confidence

A new NuGetManifestLoader class has been introduced to handle fetching and caching of NuGet package manifests. This change centralizes the logic for constructing manifest URLs, making HTTP requests to retrieve package metadata, and caching the results in memory. Users will experience more efficient manifest retrieval as repeated requests for the same package will be served from the cache.

src/UniGetUI.PackageEngine.Managers.Generic.NuGet/Internal · high confidence

The PowerShell 5.x package manager is now implemented as a concrete class inheriting from the new BaseNuGet abstract class, providing the specific capabilities, executable paths, and source configurations for that manager. Additionally, the internal test assembly is granted visibility to the PowerShell manager's internal members to support the expanded unit test coverage.

src/UniGetUI.PackageEngine.Managers.PowerShell · medium confidence

The package serialization system has been refactored to use a dynamic, dictionary-based approach for \InstallOptions\, allowing for more robust handling of installation settings such as pre/post commands, custom parameters, and process termination before operations. Additionally, the \SerializablePackage\ and \SerializableBundle\ classes have been migrated to a new \SerializableComponent\ base, standardizing how package data is loaded from and saved to JSON. This change also introduces configurable skip levels for minor updates and allows users to force user gsudo via a secure setting.

src/UniGetUI.PackageEngine.Serializable · high confidence

The operation history page now displays a structured, sortable list of past operations (including package, version, status, and date) with inline actions to revert, rerun, view logs, or remove entries. The log pages (including the main UniGetUI log and manager-specific logs) have been refactored to use a shared base component that supports copying, exporting, and reloading logs, with improved keyboard navigation and screen reader support via AutomationProperties. The history view also integrates with the global search box for live filtering.

src/UniGetUI.Avalonia/Views/Pages/LogPages · high confidence

The Chocolatey manager integration has been refactored into dedicated helper classes (ChocolateyDetailsHelper, ChocolateyPkgOperationHelper, and ChocolateySourceHelper) to handle package details, installation/update/uninstall operations, and source management. This change improves how the application interacts with Chocolatey, including better handling of process execution, output encoding, and error states, which should lead to more reliable package operations and source management within the UI.

src/UniGetUI.PackageEngine.Managers.Chocolatey/Helpers · high confidence

The WinGet manager implementation has been refactored, including the introduction of a new \InternalsVisibleTo\ configuration that exposes internal members to \UniGetUI.PackageEngine.Tests\ and \UniGetUI.PackageEngine.Operations\ assemblies, facilitating improved test coverage and cross-assembly access for the WinGet package manager logic.

src/UniGetUI.PackageEngine.Managers.WinGet · medium confidence

The package loading logic has been restructured into a new \AbstractPackageLoader\ base class, with specific loaders (Discoverable, Installed, Upgradable, and PackageBundles) now inheriting from it. This change introduces thread-safe, asynchronous package loading, allowing the UI to remain responsive during package scans. The new architecture also supports aborting long-running load operations and provides a consistent event-driven interface for package changes, improving stability and performance across all package lists.

src/UniGetUI.PackageEngine.PackageLoader · high confidence

The package engine now distinguishes between valid imported packages and invalid ones. A new \ImportedPackage\ class handles packages that can be successfully imported and registered, while \InvalidImportedPackage\ represents packages that failed import, exposing properties like \IsChecked\ and \OverridenOptions\ to allow users to override settings for these items. This change improves how the application handles mixed states of imported packages, ensuring that invalid imports are still visible and configurable in the UI.

src/UniGetUI.PackageEngine.PackageManagerClasses/Packages · medium confidence

The application no longer bundles the Chocolatey CLI; instead, it detects the system installation or falls back to a local path. This change also adds proxy support for Chocolatey, allowing users to configure proxy settings that are passed to the CLI. Additionally, internal visibility for tests is explicitly granted to the test project.

src/UniGetUI.PackageEngine.Managers.Chocolatey · high confidence

The Scoop package manager integration has been significantly refactored to improve reliability and feature parity. The implementation now explicitly declares required dependencies (Scoop-Search and Git) with automatic installation logic, ensuring a smoother initial experience. Source configuration has been expanded to include additional official buckets (sysinternals, php, nerd-fonts, nonportable, java, games) and the manager now supports custom architectures and scopes. The codebase has been modernized with async/await patterns, improved logging, and better resource disposal to prevent issues like console window pauses on failure.

src/UniGetUI.PackageEngine.Managers.Scoop · medium confidence

The Scoop package manager integration has been refactored into three new helper classes: ScoopPkgDetailsHelper, ScoopPkgOperationHelper, and ScoopSourceHelper. These classes encapsulate the logic for retrieving package details (such as descriptions, installers, and metadata), executing operations (install, update, uninstall) with proper argument handling and error recovery, and managing Scoop sources (buckets). This change improves code organization and maintainability for the Scoop backend.

src/UniGetUI.PackageEngine.Managers.Scoop/Helpers · high confidence

The media assets directory has been updated with new branding files, including a new icon, wordmark, and splash screen designs. Specifically, the \media/assets\ directory now contains updated SVG files for the Devolutions logo and iconography (e.g., \devolutions-unigetui-color.svg\, \devolutions-unigetui-icon.svg\, \splash-dark.svg\, \splash-light.svg\). These changes reflect a refresh of the visual identity, providing new vector assets for the application's UI and splash screens.

media · high confidence

The contributors list in the core data assets has been updated to reflect the latest set of project contributors, ensuring the UI displays the most current recognition of those who have contributed to the project.

src/UniGetUI.Core.Data/Assets · high confidence

The WinGet package manager integration has been restructured to improve reliability and performance. A new helper interface (IWinGetManagerHelper) and several implementation classes (NativePackageHandler, NativeWinGetHelper, PingetCliHelper, WinGetCliHelper) have been introduced to manage WinGet operations. Notably, the system now attempts to activate the WinGet API via COM first, falling back to lower-trust COM registration if that fails, and then to the CLI. This change also integrates the 'Pinget' library for CLI operations and optimizes package icon loading and memory management.

src/UniGetUI.PackageEngine.Managers.WinGet/ClientHelpers · high confidence

The NPM package manager now correctly parses and handles npm alias packages (e.g., 'npm:eslint@^9.x') by introducing a new \NpmPackageIdentifier\ helper. This component distinguishes between standard and aliased package identifiers, ensuring that operations like updates and installations work correctly for aliased dependencies.

UniGetUI.PackageEngine.Managers.Npm · medium confidence

Add automated tests for language engine and data; Added automated CLI end-to-end test manifests and a ProductInfo updater testing guide; Added automated tests for JSON serialization safety and download resume logic; Added tests for serializable package classes and update duplicate detection; Added unit tests for auto-update, CLI, and IPC subsystems; Added unit tests for core data and update guard logic; Added unit tests for core utility classes; Added unit tests for logging functionality; Added unit tests for settings migration, secure settings, and import/export; Added unit tests for the TelemetryHandler; Added unit tests for the icon cache engine and database; Expanded test coverage for package managers and broker request building.

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

• First survey — no prior run to compare against. CAI 49.

• Code Health 58
• Architecture 94
• Maturity 64
• Readiness 57
• Security 35

• 300 commits — 207 feature/other, 93 fixes

• src/UniGetUI.Avalonia — 118 commits
• src/Languages — 46 commits
• src/UniGetUI — 30 commits
• (root) — 15 commits
• src/UniGetUI.PackageEngine.Managers.WinGet — 15 commits
• .github/workflows — 12 commits
• WebBasedData/screenshot-database-v2.json — 7 commits
• src/UniGetUI.PackageEngine.Tests — 7 commits
• src/UniGetUI.PackageEngine.Managers.Apt — 5 commits
• src/UniGetUI.Core.LanguageEngine — 4 commits
• src/SharedAssets — 3 commits
• src/UniGetUI.PackageEngine.Managers.Chocolatey — 3 commits
• src/UniGetUI.PackageEngine.Operations — 3 commits
• .github/CODEOWNERS — 2 commits
• InstallerExtras/CustomMessages.iss — 2 commits
• src/UniGetUI.Core.Data — 2 commits
• src/UniGetUI.PackageEngine.AgentBroker — 2 commits
• src/UniGetUI.PackageEngine.Managers.PowerShell — 2 commits
• src/UniGetUI.PackageEngine.Managers.Scoop — 2 commits
• InstallerExtras/CodeDependencies.iss — 1 commit

• fix: Avalonia: Fix UnauthorizedAccessException with webview (#4692)
• fix: Avalonia: Fix main window not draggable by touch (#4869)
• fix: Avalonia: Fix notification not working (#4864)
• fix: Avalonia: Fix transparent strip on right/bottom edges of Avalonia window (#4830)
• fix: Avalonia: Fix webview crash. CR:forestmaxime (#4777)
• fix: Avalonia: add splash screen + fix package card / search bar visual issues (#4828)
• fix: Fix "Uninstall package, then update it" failing on WinGet packages (#5077)
• fix: Fix #4795 - Update GnuPG icon and remove associated images (#4796)
• fix: Fix Apt update detection on non-English locales (#4627)
• fix: Fix Avalonia main window growing on every restart (Windows) (#5056)
• fix: Fix Avalonia startup responsiveness and maximize (#4673)
• fix: Fix Bun manager detection, search, and global package listing (#4880)
• fix: Fix Chocolatey installer validation (#4660)
• fix: Fix ForceInversion checkboxes not persisting user choice (#5092) (#5122)
• fix: Fix Homebrew installation error on Apple Silicon (#4635)
• fix: Fix Italian installer message formatting (#5180)
• fix: Fix Mica readability: links, window border, overlay filter pane (#4920)
• fix: Fix NativeAOT WinGet and startup COM paths (#5087)
• fix: Fix Pinget detection and Avalonia source filters (#4683)
• fix: Fix PowerShell 7 updates list silently dropping all modules (#4824)
• …and 280 more

• 1 containers · 2 bounded contexts · 0 dependency edges (baseline)

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

Devolutions/UniGetUI 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.