files-community/Files

This is a modernized Windows file manager application that manages local, network, and cloud storage through a modular, service-oriented architecture. It provides comprehensive file system operations, including advanced archive handling, Git integration, and FTP support, all orchestrated by a unified action-based command system. The interface features a highly customizable UI with dual-pane navigation, tabbed browsing, and a rich set of context-aware actions for file and folder management.

111 changes.

The project underwent a comprehensive architectural overhaul, migrating to a modern .NET 10 solution structure with centralized build and dependency management. This period introduced a new modular action-based command system, expanded UI components like the Shelf and Info panes, and added significant features including Git integration, cloud drive detection, and a redesigned properties window.

43 changes.

This period focused on constructing a comprehensive, reusable UI control library and a modular service architecture. The team introduced numerous new controls such as the Omnibar, BreadcrumbBar, and AdaptiveGridView, while simultaneously refactoring the application's internal structure with new services for storage, Windows integration, and configuration management.

4 changes.

This period focused on enhancing dual-pane navigation by adding actions to open folders and the current directory in the adjacent pane. It also introduced copy, cut, and delete capabilities for the Shelf pane and refactored Git integration into a dedicated service.

Users can now open a selected folder in the other pane of a dual-pane view. This new action is available for folders in the main content area, from the home page context menu, and from the sidebar context menu, allowing users to quickly navigate into a folder in the adjacent pane while keeping the current view active.

src/Files.App/Actions/Navigation/OpenInOtherPane · high confidence

The application now supports accessing files and folders stored on FTP servers. This change introduces a new \FtpStorageService\ and associated helper classes (\FtpHelpers\, \FtpManager\) that enable reading, writing, and managing FTP-based storage, allowing users to interact with FTP resources as if they were local files.

src/Files.App.Storage/Ftp · high confidence

A new action, LaunchPreviewPopupAction, has been introduced to handle the logic for opening and switching the preview popup for a selected file. This change implements the execution flow for the preview feature, allowing users to toggle the preview pane via the Space hotkey or menu commands.

src/Files.App/Actions/Content/PreviewPopup · medium confidence

A new ShareItemAction class has been added to handle the sharing of selected files. This implementation includes localization for labels and descriptions, defines a share glyph, and restricts executability to specific page types (excluding Recycle Bin, Home, FTP, and Zip folders). The action validates that items are shareable and leverages the Windows DataTransfer API to perform the share operation.

src/Files.App/Actions/Content/Share · high confidence

Users can now open all files and folders associated with a specific tag via a new 'Open All' action, and remove all tags from selected files using a new 'Remove Tags' action. These new commands are implemented in the Tags action directory, providing direct access to bulk tag operations.

src/Files.App/Actions/Content/Tags · high confidence

A new background task, UpdateTask, has been introduced to handle periodic maintenance. This task refreshes the Windows jump list by updating string resources and clearing automatic items to avoid localization issues, and it also removes previous version log files (debug.log and debug\_fulltrust.log) from the local application data folder.

src/Files.App.BackgroundTasks · high confidence

A new \FileLogger\ implementation has been added to the shared utilities, enabling application logs to be written to a file. The logger uses a lock to ensure thread-safe writes and includes a \PurgeLogs\ method that retains only the last 100 lines of the log file, automatically trimming older entries to prevent unbounded growth.

src/Files.Shared/Utils/Logger · high confidence

Added DigitalSignaturesUtil.cs, a new utility class that implements the core logic for verifying and displaying digital signatures on files. This includes methods to load signature information from a file path and to display a detailed signer information dialog, enabling the application to process cryptographic signatures using Windows cryptographic APIs.

src/Files.App/Utils/Signatures · high confidence

A new data model, OmnibarPathModeSuggestionModel, has been introduced to support the Omnibar feature. This internal record implements IOmnibarTextMemberPathProvider to map Path and DisplayName properties, enabling the UI to display and interact with path-based suggestions in the omnibar.

Files.App · high confidence

Users can now use the 'Play All' action to open all selected media files, and the 'Refresh Items' action to refresh the current view, with both actions featuring localized labels, descriptions, and hotkey support.

src/Files.App/Actions/Content · high confidence

A new SamplePanel control has been introduced to the application's UI library. This component provides a structured layout featuring a header, a primary content area (MainContent), and a right-side panel (SideContent). The side panel includes a SelectorBar for navigation and displays a 'Nothing to show' message when the side content is empty. The control manages visual states to toggle the visibility of the placeholder text based on the presence of side content.

src/Files.App.Controls/SamplePanel · high confidence

The application now includes a new logging infrastructure that captures unhandled exceptions and logs them to Sentry for remote error tracking. This includes a new \SentryLogger\ and \SentryLoggerProvider\ implementation that maps internal log levels to Sentry severity levels, ensuring that only relevant error and critical exceptions are reported while filtering out informational and debug messages.

src/Files.App/Utils/Logger · high confidence

Introduced new UI components to display drive storage information. The \StorageBar\ control renders a horizontal bar indicating usage percentage, with visual states for safe, caution, critical, and disabled conditions. The \RingShape\ primitive draws circular or elliptical rings, supporting configurable start/end angles, sweep direction, and radius dimensions. These controls enable the Details Pane to show drive storage status visually.

src/Files.App.Controls/Storage/StorageBar · high confidence

A new StorageRing control has been introduced in the Files.App.Controls library to visualize storage usage as a circular progress indicator. The component features a value ring and a track ring, with visual states for Safe, Caution, Critical, and Disabled conditions. It supports configurable properties for ring thickness, angles, and percentage thresholds, allowing users to monitor storage levels with distinct color coding for different status states.

src/Files.App.Controls/Storage/StorageRing · high confidence

Users can now open the current folder in the other pane of a dual-pane view. This new action, available in the Dual Pane category, allows users to duplicate the current directory into the adjacent pane, provided the environment supports multi-pane views and the current location is not the Recycle Bin.

src/Files.App/Actions/Navigation/OpenCurrentFolderInOtherPane · high confidence

Users can now perform copy, cut, and delete operations on items within the Shelf pane. This change introduces new action classes (CopyItemFromShelfAction, CutItemFromShelfAction, DeleteItemFromShelfAction) that interact with the IShelfContext to manage item selection and execute file system operations. The IShelfContext interface and its implementation (ShelfContext) provide the necessary state management for tracking selected items in the shelf, enabling these file management actions to function correctly within that specific UI context.

src/Files.App/Actions/Shelf, src/Files.App/Data/Contexts/Shelf · high confidence

Users can now copy items from the sidebar to the clipboard, as well as pin and unpin folders to the sidebar's quick access list. New action classes (CopyItemFromSidebarAction, PinFolderToSidebarAction, UnpinFolderFromSidebarAction) implement the \[GeneratedRichCommand\] pattern, providing context-sensitive availability and localized labels for these sidebar-specific operations.

src/Files.App/Actions/Sidebar · high confidence

Introduced a new C++ DLL project (Files.App.SaveDialog) that implements a custom file save dialog. The module exports COM classes for IFileSaveDialog, IFileDialog2, and IFileDialogCustomize, and includes event handling for dialog interactions. The build configuration targets Win32, x64, and arm64 platforms using the v145 toolset.

src/Files.App.SaveDialog · high confidence

Added a new set of enumerations in the \Files.App.Data.Enums\ namespace to support various application features. This includes constants for file system status codes, archive compression and splitting options, view layout sizes, and UI states. These enums provide the underlying data structures for features such as file operations, 7z archive settings, and the new Cards View layout.

src/Files.App/Data/Enums · high confidence

New helper classes, PackageHelper and SoftwareHelpers, have been added to the environment utilities. PackageHelper checks if a Windows app package is installed by querying its URI support. SoftwareHelpers checks for the presence of Microsoft Visual Studio Code by scanning the Windows Registry, with specific handling for SecurityException edge cases during registry access.

src/Files.App/Helpers/Environment · high confidence

Users can now rotate selected images left or right. This change introduces the underlying action classes (BaseRotateAction, RotateLeftAction, RotateRightAction) that handle the rotation logic and update the UI state, addressing previous issues where rotate options were sometimes hidden.

src/Files.App/Actions/Content/ImageManipulation · high confidence

Users can now install certificates, fonts, and INF drivers directly from the file manager. New actions have been added for each file type, allowing users to trigger installation processes for these specific content types. The font installation action also displays progress in the status center.

src/Files.App/Actions/Content/Install · high confidence

Users can now pin items and folders to the Windows Start menu and unpin them from it. This change introduces new 'Pin to Start' and 'Unpin from Start' actions, allowing users to manage their Start menu shortcuts directly from the file manager interface.

src/Files.App/Actions/Start · high confidence

The application introduces new data models to support security and system-level file operations. \AccessControlEntry\, \AccessControlList\, and \AccessControlPrincipal\ provide the data structure for displaying and managing file access control lists (ACLs) and individual permissions. Additionally, \CertNodeInfoItem\ is added to represent certificate node information, while \ActionWithParameterItem\ and \ModifiableActionItem\ support command and hotkey configurations. These models enable the UI to display and interact with security properties and system file attributes.

src/Files.App/Data/Items · high confidence

The application now supports a system tray icon, allowing users to access quick actions like opening the context menu, restarting the app, or quitting directly from the Windows notification area. This new feature includes a dedicated \SystemTrayIcon\ class and its associated window handler to manage the tray icon's visibility, tooltip, and icon state.

src/Files.App/Utils/Taskbar · high confidence

The Omnibar control has been introduced to the application, providing a unified search and mode-switching interface. This includes the main \Omnibar\ component with event handling for text changes, mode switching, and suggestion selection, alongside supporting classes like \OmnibarMode\ for individual search modes, \OmnibarModeSeparator\ for visual separation, and various event argument and reason enums. The implementation handles focus management, keyboard navigation, and dynamic mode updates.

src/Files.App.Controls/Omnibar · high confidence

The app introduces a new set of extension methods in the Files.App.Extensions namespace to support various features. These include middle-click auto-scrolling for list controls, improved handling of dispatcher queue operations to prevent crashes, and new utilities for formatting fractions, images, and localized strings. Additionally, the changes add helpers for keyboard accelerators, shell new menu entries, and Win32 handle validation, enhancing the user experience and application stability.

src/Files.App/Extensions · high confidence

The ThemedIcon control library has been significantly expanded with new icon styles across multiple categories. New action icons include Copying, Moving, Extracting, Recycle, Delete, Success, and Paused. Navigation icons for Forward, Up, Back, and Refresh have been added in both 16px and 12px sizes. Git-related icons for Pull, Push, Sync, Commit, Issue, Branch, and BranchNew are now available. Additionally, utility icons for Grouping, Sorting, and Filter have been introduced. All new icons are defined in the corresponding XAML style files within the ThemedIcon/Styles directory.

src/Files.App.Controls/ThemedIcon/Styles · high confidence

A new context layer has been added to centralize the state of the file explorer's display settings. This includes an enum for layout types (Details, List, Cards, Grid, Columns, and Adaptive) and a context class that synchronizes sorting, grouping, and directory/file ordering preferences with the active folder's view model. This change provides a unified way to track and update layout and sorting behavior across the application.

src/Files.App/Data/Contexts/DisplayPage · high confidence

A new HomePageContext class and its IHomePageContext interface have been added to manage the state of the home page. This includes tracking the last right-clicked item, the associated context menu flyout, and the list of selected tagged items, providing a centralized way to handle home page interactions.

src/Files.App/Data/Contexts/HomePage · high confidence

Added the Status Center user interface, including a new SpeedGraph control that renders a dynamic speed graph using WinUI Composition APIs. The Status Center now displays a list of status items with headers, icons, and action buttons, while the SpeedGraph component visualizes speed data points using a new C\# code-behind and XAML layout.

src/Files.App/UserControls/StatusCenter · high confidence

A new ThemedIcon control has been added to the application's UI library. This component supports multiple icon styles (Outline, Filled, and Layered) and dynamic color states (Normal, Critical, Caution, Success, Neutral, Accent, and Custom). It automatically adapts its appearance based on the host control's toggle and enabled states, and respects system theme resources for consistent visual feedback across the application.

src/Files.App.Controls/ThemedIcon · high confidence

The application now includes a suite of new services in the Windows directory to manage Windows-specific features. This includes WindowsJumpListService for managing the taskbar and Start Menu jump lists, WindowsRecentItemsService for tracking recent files and folders, WindowsQuickAccessService for managing pinned folders in the sidebar, and WindowsStartMenuService for handling secondary tiles. Additionally, new services handle Windows compatibility settings, INI file parsing, desktop wallpaper management, and security elevation checks. These changes provide the foundation for deeper Windows OS integration, including proper handling of COM objects, file system watchers, and shell interactions.

src/Files.App/Services/Windows · high confidence

Added a new Windows storage layer in src/Files.App.Storage/Windows, including the IWindowsStorable interface and WindowsStorableHelpers for handling shell interactions, thumbnails, file attributes, and context menus. New managers were introduced for the system tray, taskbar, and drive change notifications, alongside a STATask utility for executing work on STA threads. The change also adds support for Windows object picking and jump list management.

src/Files.App.Storage/Windows · high confidence

Added new abstract base classes (BaseStorageFile, BaseStorageFolder, BaseBasicProperties, etc.) in the Files.App.Utils.Storage namespace to provide a unified, abstracted interface for storage items. These classes implement standard file and folder operations (copy, move, rename, read/write text/bytes) and expose properties like DateCreated and DateModified, enabling consistent handling of different storage providers (e.g., FTP, Zip, Shell) through a common API.

src/Files.App/Utils/Storage/StorageBaseItems · high confidence

The application introduces a new \SizeProvider\ service layer to handle folder and drive size calculations. This includes a \CachedSizeProvider\ for recursive size computation with caching, a \DrivesSizeProvider\ to manage per-drive instances, and a \UserSizeProvider\ that bridges the service with user settings (specifically the \CalculateFolderSizes\ preference). The change also adds supporting types like \ISizeProvider\, \SizeChangedEventArgs\, and \SizeChangedValueState\ to support this new behavior.

src/Files.App/Services/SizeProvider · high confidence

The application now uses a dedicated \CloudDrivesManager\ and \CloudDrivesDetector\ to detect and manage cloud storage providers. This includes a new \CloudDriveSyncStatus\ enum and UI helper to indicate the synchronization state of cloud folders (e.g., online, offline, pinned, excluded). The system supports a wide range of providers including OneDrive, SharePoint, Yandex Disk, pCloud, Nutstore, Seadrive, Autodesk, MEGA, Nextcloud, Jottacloud, ownCloud, Proton Drive, Lucid Link, kDrive, SyncDrive, MagentaCLOUD, and OX Drive. The manager handles loading icons and updating the sidebar with detected cloud drives.

src/Files.App/Utils/Cloud · high confidence

A new out-of-process WinRT server executable (Files.App.Server) has been added to handle long-running background tasks. This standalone process registers activation factories for public sealed classes in the Files.App.Server namespace, allowing external clients to activate them. The server monitors application instances and logs exceptions to a debug log file, ensuring the server remains active until all monitored processes exit.

src/Files.App.Server · high confidence

The application now uses a new \IRichCommand\ interface and associated implementations (\ActionCommand\, \ModifiableCommand\, \NoneCommand\) that expose detailed metadata about each command. This includes support for custom hotkeys, extended labels, automation names, and access keys, enabling more accessible and customizable user interfaces.

src/Files.App/Data/Commands · high confidence

The application now features a unified storage abstraction layer, introducing a new \Files.App.Utils.Storage\ namespace with base classes for storage items. This includes \BaseStorageFile\, \BaseStorageFolder\, and query result wrappers that standardize file and folder operations. Additionally, full file operation support for FTP servers has been added, allowing users to browse, copy, move, and delete files on remote FTP servers as if they were local. The implementation includes specific storage item classes for FTP (\FtpStorageFile\, \FtpStorageFolder\), native Windows files (\NativeStorageFile\), shell items (\ShellStorageFile\, \ShellStorageFolder\), and system files (\SystemStorageFile\), all implementing a consistent interface for file management.

src/Files.App/Utils/Storage/StorageItems · high confidence

Added the AdaptiveGridView control, which automatically adjusts the number of columns and item widths based on the available display space. This new UI component supports features like one-row mode, stretchable content for single rows, and command binding for item clicks, allowing the grid to adapt to different form factors and screen resolutions.

src/Files.App.Controls/AdaptiveGridView · high confidence

Added a new BladeView control that hosts BladeItem children in a horizontal scrolling list, supporting both normal and fullscreen display modes. The BladeItem component includes properties for managing visibility, title bar styling, and a resizer for adjusting width. This change also includes the corresponding automation peers for accessibility support.

src/Files.App.Controls/BladeView · high confidence

A new C++/WinRT-based launcher component has been added to the project, containing the core logic for opening folders and selecting files. This includes the FilesLauncher executable and the OpenInFolder helper class, which interact with the Windows Shell to manage file operations and communicate with the main application via URI schemes.

src/Files.App.Launcher · high confidence

Added the InfoPane and ShelfPane user controls to the application. The InfoPane provides a tabbed interface for viewing file details and previews, while the ShelfPane introduces a new 'Shelf' feature that allows users to drag and drop files into a temporary holding area for batch operations like copy, cut, or delete.

src/Files.App/UserControls/Pane · high confidence

Added a new \LibraryManager\ class in \src/Files.App/Utils/Library\ that manages the lifecycle of Windows Libraries. This component monitors the system Libraries folder for changes (creation, modification, deletion) and exposes methods to list, create, and update libraries, effectively centralizing library state management within the application.

src/Files.App/Utils/Library · high confidence

Added a new TagsContext class and its ITagsContext interface to manage the state of selected tags. The context subscribes to SelectedTagChanged events from the sidebar and widget, updating the TaggedItems property to reflect the currently selected tags.

src/Files.App/Data/Contexts/Tags · high confidence

Added a new abstract base class, BaseTemplateSelector, which simplifies the implementation of data template selection by providing sealed overrides for XAML's SelectTemplateCore methods. Additionally, a new FileSystemDialogItemSelector was introduced to handle template selection for file system dialog items, specifically distinguishing between conflict and default item templates.

src/Files.App/Data/TemplateSelectors · high confidence

Added a new C++/COM-based component (Files.App.OpenDialog) that implements the IFileOpenDialog interface. This DLL provides a custom file picker that, when invoked, launches the Files application via a protocol URI to handle the selection, rather than displaying the standard Windows open dialog.

src/Files.App.OpenDialog · high confidence

Added the IMultiPanesContext interface and its MultiPanesContext implementation to centralize tracking of the active pane, the active pane or column, and the shell pane arrangement. This context exposes events for active pane changes and arrangement updates, allowing other parts of the application to react to multi-pane state transitions.

src/Files.App/Data/Contexts/MultiPanes · high confidence

The application's data layer now exposes a comprehensive set of new interfaces to manage user preferences and system interactions. Settings are organized into dedicated services for general behavior (startup, tabs, widgets), appearance (themes, colors, fonts), folder and layout options, and file tags. Additional contracts define services for managing dialogs, image/icon caching, quick access sidebar items, network locations, and preview popups. This refactoring centralizes configuration and UI logic into distinct, testable components.

src/Files.App/Data/Contracts · high confidence

Added new service classes to handle specific storage operations: IconCacheService for caching file icons, StorageArchiveService for managing archive compression and extraction, StorageCacheService for caching display names, StorageDevicesService for managing removable drives, StorageNetworkService for network locations and shortcuts, StorageSecurityService for managing file security descriptors, and StorageTrashBinService for managing the Recycle Bin. These services implement dedicated interfaces to encapsulate their respective functionalities.

src/Files.App/Services/Storage · high confidence

Added new classes and interfaces in the \src/Files.App/Utils/Storage/History\ and \src/Files.App/Utils/Storage/Operations\ directories to support undo/redo functionality for file operations. This includes \IStorageHistory\, \StorageHistory\, \IStorageHistoryOperations\, \StorageHistoryOperations\, and \StorageHistoryWrapper\ to track and manage operation history, allowing users to reverse or reapply actions like copy, move, and delete.

src/Files.App/Utils/Storage/Operations · high confidence

Added new thread-safe collection classes (BulkConcurrentObservableCollection, ConcurrentCollection, BlockingListEnumerator) to the Files.App.Utils.Storage namespace. These classes provide synchronized access to file collections, supporting grouped and sorted file lists with improved performance and stability. The changes also include helper classes (GroupingHelper, SortingHelper) that define how files are grouped by attributes like name, size, date, and type, and how they are sorted, ensuring thread-safe operations during file system interactions.

src/Files.App/Utils/Storage/Collection · high confidence

A new \DynamicDialog\ framework has been added to the application, providing a standardized way to display dialogs with customizable titles, messages, and buttons. This includes specific implementations for common scenarios such as creating new items (with validation and default naming), handling file-in-use conflicts (offering retry or skip options), and managing credential entry. The \DialogDisplayHelper\ and \DynamicDialogFactory\ classes centralize dialog creation, ensuring consistent styling and behavior across the app.

src/Files.App/Helpers/Dialog · high confidence

The \Files.Core.Storage\ module now provides a set of new interfaces and extension methods to standardize file system interactions. This includes the \IStorageService\ interface for retrieving files and folders by ID, along with \TryGet\ extension methods that return null instead of throwing exceptions when items are not found. Additionally, new interfaces (\IWatcher\, \IDeviceWatcher\, \ITrashWatcher\) and event argument classes (\DeviceEventArgs\) are introduced to handle file system change notifications, while \IDirectCopy\ and \IDirectMove\ interfaces enable direct copy and move operations on storage items.

src/Files.Core.Storage · medium confidence

The Properties window has been restructured from a single-page view into a tabbed interface, introducing dedicated tabs for Compatibility, Hashes, and Digital Signatures, alongside a reorganized layout for Security and Customization. Users can now view and edit file hashes (including CRC32, MD5, SHA1, SHA256, SHA384, and SHA512), adjust Windows compatibility settings, and verify digital signatures directly from the Properties window. The refactoring also introduces a new \BasePropertiesPage\ and \MainPropertiesViewModel\ to manage navigation between these distinct property pages, improving the overall organization and usability of file and folder properties.

src/Files.App/ViewModels/Properties · high confidence

The application has replaced the embedded LiteDB database with a new registry-based storage system for folder layout preferences. This change introduces a new \LayoutPreferencesDatabase\ that persists settings such as sort options, column visibility, and view modes directly into the Windows Registry, ensuring that layout configurations are retained across updates and shared more reliably across tabs. The migration also includes new helper classes like \AdaptiveLayoutHelpers\ and \LayoutHelpers\ to manage these preferences and update open tabs when settings change.

src/Files.App/Helpers/Layout · high confidence

The application's primary user interface components—including the main window layout, the home page, the release notes page, the shell panes for file browsing, and the splash screen—have been restructured into the \src/Files.App/Views\ directory. This change consolidates the XAML templates and code-behind for these critical views, ensuring they are properly integrated into the new project structure for improved maintainability and feature isolation.

src/Files.App/Views · high confidence

Users can now open items from the Home page and the Sidebar in a new window via dedicated context menu actions. The new \OpenInNewWindowFromHomeAction\ and \OpenInNewWindowFromSidebarAction\ classes implement the \IAction\ interface, allowing users to launch folders or files in a separate window instance, distinct from the main application window. This complements the existing global 'Open in New Window' functionality by providing context-specific triggers.

src/Files.App/Actions/Navigation/OpenInNewWindow · high confidence

The application introduces new action classes to handle opening items in a new pane from the Home page and Sidebar. The base class \BaseOpenInNewPaneAction\ provides shared logic for executing the open-in-new-pane command, while specific implementations (\OpenInNewPaneFromHomeAction\ and \OpenInNewPaneFromSidebarAction\) handle context-specific conditions, such as checking for right-clicked items on the Home page or location items in the Sidebar. These changes replace previous hardcoded or less structured approaches with a more modular, extensible action-based architecture.

src/Files.App/Actions/Navigation/OpenInNewPane · high confidence

Users can now execute files as an elevated administrator or as a different user directly from the context menu. This change introduces new action classes (RunAsAdminAction, RunAsAnotherUserAction) that leverage the existing RichCommand infrastructure to provide these execution modes, alongside a refactored RunWithPowershellAction that now correctly uses the working directory for script execution.

src/Files.App/Actions/Content/Run · high confidence

A new BreadcrumbBar control has been introduced to the Files.App.Controls library, providing a navigable breadcrumb trail for file system paths. The component includes a root item, an ellipsis button for collapsed items, and an ItemsRepeater for the main path segments. It supports item click events, right-click context menus, and accessibility features via an AutomationPeer. The layout logic handles collapsing items into an ellipsis when space is limited, and the UI includes chevron buttons with attached flyouts for each item.

src/Files.App.Controls/BreadcrumbBar · high confidence

The Files app now uses a new \DateTimeFormatter\ service in \src/Files.App/Services/DateTimeFormatter\ to handle date and time display. This introduces a factory pattern that supports three distinct formatting modes: Application (relative time like '2 hours ago'), System (using system locale settings), and Universal (ISO 8601 format). The \UserDateTimeFormatter\ acts as a bridge, dynamically switching between these modes based on the user's settings, ensuring that date and time labels in the file list and other UI elements reflect the user's preferred format.

src/Files.App/Services/DateTimeFormatter · high confidence

Users can now perform core Git operations directly from the file manager interface. New actions have been added to initialize a folder as a Git repository, clone a repository, fetch updates, pull remote changes, push local commits, and perform a full sync. Each action is exposed in the command menu with appropriate labels, descriptions, and icons, and their availability is dynamically enabled based on the current folder's Git status.

src/Files.App/Actions/Git · high confidence

A new GridSplitter control has been added to the application, allowing users to interactively resize columns and rows within a Grid layout. The control supports configuring the resize direction (columns, rows, or automatic detection), the specific rows or columns to affect (current, previous, next), and customizes the cursor appearance and behavior on hover and during manipulation. The implementation includes full XAML styling with theme-aware colors and visual states, along with keyboard navigation support (arrow keys and Ctrl for larger steps).

src/Files.App.Controls/GridSplitter · high confidence

A new \KeyboardShortcut\ user control has been added to the \src/Files.App/UserControls/KeyboardShortcut\ directory. This component renders keyboard shortcuts as styled items (Outlined, Filled, or TextOnly) with configurable sizes (Small, Medium, Large). It parses hotkey collections and dynamically generates a visual representation of key combinations (e.g., Ctrl+Shift+T) for use in the Command Palette or other UI areas.

src/Files.App/UserControls/KeyboardShortcut · high confidence

The Toolbar control now supports a dynamic overflow menu for items that do not fit in the available space, with configurable overflow behavior (Auto, Always, Never) and three size presets (Small, Medium, Large) that define minimum button dimensions. The ToolbarButton component provides visual states for normal, pointer-over, pressed, and disabled conditions, along with support for icons, labels, and content templates. The ToolbarItem class acts as a data model that maps to specific UI controls (buttons, flyout buttons, separators) and manages sub-items and command bindings.

src/Files.App.Controls/Toolbar · high confidence

A new \IAction\ interface and \BaseUIAction\ base class have been introduced to standardize how commands are defined and executed. The \IAction\ interface defines a common contract for all actions, including properties for labels, descriptions, hotkeys, and execution logic. This provides a consistent foundation for implementing and managing UI actions across the application.

src/Files.App/Actions · high confidence

Added new actions to open the log file, settings file, release notes, and Storage Sense. Users can now open the application's debug log, edit the settings file directly, view release notes, and launch the Windows Storage Sense utility. Additionally, the toolbar can now be customized, and the command palette can be opened via a keyboard shortcut.

src/Files.App/Actions/Open · high confidence

Added new action classes to toggle the details pane, dot files setting, dual pane mode, filter header, info pane, preview pane, shelf pane, file extensions, hidden items, sidebar, and toolbar. Each action implements the IAction or IToggleAction interface, providing labels, descriptions, hotkeys, and execution logic to control the visibility or state of these UI elements.

src/Files.App/Actions/Show · high confidence

The application introduces several new dialog components to support emerging features: a CreateShortcutDialog for generating new shortcuts, a BulkRenameDialog for renaming multiple files, an AddBranchDialog for Git branch management, a CloneRepoDialog for cloning repositories, and an AddItemDialog for adding new items. Existing dialogs have been updated to support advanced archive creation options (including 7z dictionary and word size, splitting size, and CPU threads), encoding selection during extraction, and improved conflict resolution with an 'Apply to all' option. These changes expand user control over file management, archiving, and version control workflows.

src/Files.App/Dialogs · high confidence

Added new actions to set an image as the app background, lock screen, desktop wallpaper, or desktop slideshow. These new commands are implemented in the Background folder, extending the existing IAction interface with specific behaviors for each target. Users can now choose to apply an image to multiple system contexts directly from the file context menu.

src/Files.App/Actions/Content/Background · high confidence

Added new user controls to the application's menu system: \FileTagsContextMenu\ for managing file tags, \MenuFlyoutHeaderItem\ for header-style menu items, \MenuFlyoutItemWithImage\ for items with bitmap icons, \MenuFlyoutItemWithThemedIcon\ for items with themed icons, \MenuFlyoutSubItemCustomProperties\ for sub-item properties, and \ToggleMenuFlyoutItemWithThemedIcon\ for toggleable menu items with themed icons. These components provide enhanced visual customization and icon support for the application's context menus and flyouts.

src/Files.App/UserControls/Menus · high confidence

The application introduces several new classes in the Files.App.Data.Parameters namespace to handle navigation and tab state. These include ColumnParam for column layout context, NavigationParams for path and selection state, PropertiesPageNavigationParameter for property page context, SettingsNavigationParams for settings page kind, and TabBarItemParameter for serializing tab bar item states.

src/Files.App/Data/Parameters · high confidence

The codebase introduces new dialog view models in the \src/Files.App/ViewModels/Dialogs\ directory, including \ReorderSidebarItemsDialogViewModel\ for managing the order of sidebar items, and \AddItemDialogViewModel\ along with its associated list item model to handle the creation of new files, folders, and shortcuts. These changes support the new UX for creating items and reordering the sidebar, providing the necessary state management and command bindings for these specific user interactions.

src/Files.App/ViewModels/Dialogs · high confidence

The file manager now supports three distinct behaviors for multi-selecting items via drag: 'Extend' (Shift+drag) adds items to the current selection, 'Ignore' (simple drag) replaces the selection, and 'Invert' (Ctrl+drag) toggles the state of items within the selection rectangle. These new \ItemSelectionStrategy\ implementations in \src/Files.App/UserControls/Selection\ replace the previous selection logic, allowing users to refine their selections more precisely when using the mouse or touchpad.

src/Files.App/UserControls/Selection · high confidence

The file preview pane now features dedicated user controls for rendering previews of various file types, including code, HTML, images, folders, media, PDFs, rich text, and plain text. This includes a new CSS preview renderer to handle syntax highlighting and prevent performance issues with complex stylesheets, as well as a Markdown preview with clickable links. These new components replace or supplement the previous preview implementation, providing a more robust and feature-rich preview experience for users.

src/Files.App/UserControls/FilePreviews · high confidence

The Files.App/Actions/FileSystem directory now contains a comprehensive set of new action classes that implement the IAction interface for core file system operations. These include actions for creating new items (files, folders, shortcuts, and alternate data streams), copying item paths (with and without quotes), deleting items (to recycle bin or permanently), pasting items (as shortcuts or to selection), opening items and their parent folders, flattening folders, and emptying the recycle bin. Each action defines its own executable state, hotkeys, and execution logic, enabling a more consistent and extensible command structure for file management tasks.

src/Files.App/Actions/FileSystem · high confidence

The Files application now includes new helper classes in the shared codebase to manage file extensions and paths. FileExtensionHelpers provides static methods to identify file types (such as images, audio, video, and executables) and check for specific extensions (like .ahk, .jar, .lzh, and .url). ChecksumHelpers adds support for calculating MD5, SHA1, SHA256, SHA384, SHA512, and CRC32 hashes for files. Additionally, AsyncManualResetEvent and PathHelpers provide asynchronous synchronization primitives and robust path combination and resolution utilities.

src/Files.Shared/Helpers · high confidence

Added new global actions for managing the app theme (SetDarkTheme, SetLightTheme, SetDefaultTheme, ToggleAppTheme), window states (EnterCompactOverlay, ExitCompactOverlay, ToggleCompactOverlay, ToggleFullScreen), and file operations (Undo, Redo, Search, EditPath, OpenHelp). These actions provide keyboard shortcuts and UI controls for common tasks, improving accessibility and workflow efficiency.

src/Files.App/Actions/Global · high confidence

The \src/Files.App/Helpers\ directory now includes several new helper classes: \BitmapHelper\ for converting byte arrays to \BitmapImage\ objects and rotating images; \ColorHelpers\ for converting hex and uint values to \Windows.UI.Color\; \PathNormalization\ for normalizing and combining file paths; \NaturalStringComparer\ for human-readable string sorting; \CredentialsHelpers\ for managing saved passwords; \MediaFileHelper\ for changing album covers; \LogPathHelper\ for generating hashed path identifiers; \TransferHelpers\ for handling copy/cut operations; and \RegexHelpers\ for common string patterns. These additions support file management, UI rendering, and system integration features.

src/Files.App/Helpers · high confidence

A new IMultitaskingContext interface and MultitaskingContext implementation have been added to manage tab state, exposing properties for the current and selected tabs, tab count, and tab bar control. This refactoring centralizes tab management logic, allowing the application to track and update tab selection and focus states more effectively.

src/Files.App/Data/Contexts/Multitasking · high confidence

Added a comprehensive set of new navigation and tab management actions, including controls for splitting and arranging panes (horizontal/vertical), closing tabs (single, all, other, left, right), duplicating the selected tab, reopening closed tabs, and navigating back/forward/home/up. These commands are implemented as new \IAction\ classes in the \src/Files.App/Actions/Navigation\ directory, each exposing labels, descriptions, hotkeys, and executable logic for the corresponding user-facing features.

src/Files.App/Actions/Navigation · high confidence

Users can now access Clear, Invert, Select All, and Toggle Select actions directly from the command palette. These new commands allow for quicker file selection management without needing to use keyboard shortcuts or right-click menus.

src/Files.App/Actions/Content/Selection · high confidence

Added a new set of classes and interfaces in the Files.App.Utils.Serialization namespace to manage application settings. This includes a base class for JSON-based settings storage, an observable variant that notifies UI of changes, and supporting interfaces for serialization and database access. This change introduces the underlying mechanism for persisting and sharing settings, which resolves issues where sort preferences were not applying correctly when sync was enabled.

src/Files.App/Utils/Serialization · high confidence

The source generator project now includes several new code generation and analysis capabilities. The CommandManagerGenerator automatically creates command codes, interfaces, and manager classes based on the \[GeneratedRichCommand\] attribute. A new RegistrySerializationGenerator produces serialization/deserialization code for types marked with \[RegistrySerializableAttribute\]. The StringsPropertyGenerator builds a 'Strings' class from resource files, while a corresponding analyzer and code fix provider (FSG1002) suggest replacing string literals with constants from that class. Additionally, the VTableFunctionGenerator creates vtable wrapper methods for structs using the \[GeneratedVTableFunction\] attribute. The codebase also introduces new data models (ParserItem, ParameterTypeNamePair, VTableFunctionInfo) and utility classes (EquatableArray, HashCode) to support these generators.

src/Files.Core.SourceGenerator · high confidence

The Files app introduces a new set of helper classes in the \Files.App.Utils.Storage\ namespace to manage file system interactions. This includes \DriveHelpers\ for managing drive states and ejecting devices, \FilePropertiesHelpers\ for handling the properties window lifecycle, \FileThumbnailHelper\ for generating and retrieving icons and thumbnails (including for font files), and \FolderHelpers\ for checking folder access and enumerating subfolders. Additionally, new types like \FilesystemResult\ and \FilesystemTasks\ provide a consistent way to handle file system operation outcomes and asynchronous task wrapping. These utilities support features such as improved drive detection, font thumbnail generation, and more robust error handling for storage operations.

src/Files.App/Utils/Storage/Helpers · high confidence

The Files.Shared.Extensions namespace now includes new extension methods to simplify common operations: ArrayExtensions.CloneArray for deep copying arrays; ComponentModelExtensions for retrieving enum descriptions; DateExtensions for converting FILETIME to DateTime; EnumerableExtensions for creating single-item enumerables/lists, parallel execution, and safe dictionary access; FileLoggerExtensions for configuring file-based logging; GenericExtensions for safe casting; LinqExtensions for null-safe empty checks, safe dictionary access, and set operations; SafetyExtensions for ignoring or wrapping exceptions; SerializationExtensions for async serialization; StringExtensions for left/right substring retrieval; and TaskExtensions for timeouts and chaining. These additions provide reusable helpers for data manipulation, error handling, and async workflows.

src/Files.Shared/Extensions · high confidence

The application now exposes new abstractions in the shared utilities layer to support asynchronous initialization, data serialization, and state persistence. Specifically, the codebase introduces IAsyncInitialize for managing async startup routines, IAsyncSerializer for handling data transformation, IPersistable for saving and loading state, IImage for UI image representation, and IWrapper for generic object wrapping. These interfaces provide the foundational contracts for upcoming features like the shelf and file tags, allowing the rest of the application to depend on these standardized behaviors.

src/Files.Shared/Utils · high confidence

The home page now features dedicated widgets for managing drives, pinned folders, recent files, file tags, and network locations. Users can navigate to drives and folders, open recent files, view and manage file tags, and access network locations directly from the home screen. Each widget provides quick access to these common tasks, with support for context menus, drag-and-drop, and inline actions like opening in a new tab or viewing drive details.

src/Files.App/UserControls/Widgets · high confidence

The Settings dialog has been replaced by a modern, page-based interface. Users can now access dedicated settings pages for Actions (customizing key bindings), Appearance (themes, backdrops, and colors), Advanced (startup, system tray, and cache options), and more. This change improves navigation and organizes configuration options into logical, distinct sections rather than a single dialog.

src/Files.App/Views/Settings · high confidence

The properties window has been completely redesigned to feature a left-hand sidebar for navigation between different property pages, including General, Details, Security, Hashes, and more. This new layout replaces the previous single-page or dialog-based interface, allowing users to easily switch between different categories of file information. The General page now supports editing multiple files, changing album covers, and managing hidden/read-only/compressed attributes. The Details page displays file properties in an expandable list with support for multiline comments. The Hashes page allows users to view and compare file hashes (MD5, SHA1, SHA256, etc.) and select which algorithms to display. The Compatibility page provides settings for Windows compatibility modes, high DPI, and administrator privileges. The Customization page enables users to change file icons. The Library page allows managing library locations. The new interface also includes a progress ring while loading properties, improved high-contrast support, and a consistent visual style across all tabs.

src/Files.App/Views/Properties · high confidence

The actions for sorting, grouping, and changing the layout of files have been refactored into new, individual action classes (such as AutoFitColumnsAction, GroupByAction, LayoutAction, and SortByAction) that implement the IAction interface and are decorated with \[GeneratedRichCommand\]. This change introduces a generated command system that provides consistent labels, descriptions, and hotkeys for each option, improving the consistency and maintainability of the file display controls.

src/Files.App/Actions/Display · high confidence

The navigation logic has been reorganized into dedicated helper classes. A new \MultitaskingTabsHelpers\ class provides utility methods for closing tabs (left, right, other, and all), while \NavigationHelpers\ centralizes tab creation and path-opening logic. Additionally, a \NavigationInteractionTracker\ class was introduced to handle swipe gestures for back/forward navigation, improving the user experience for touch and pen input.

src/Files.App/Helpers/Navigation · high confidence

The properties window's view models have been reorganized into a new \src/Files.App/ViewModels/Properties/Items\ directory. This refactoring introduces a modular structure with a shared \BaseProperties\ abstract class and specific implementations for different item types, including \FileProperties\, \FolderProperties\, \DriveProperties\, \CombinedFileProperties\, and \LibraryProperties\. This change improves code organization and maintainability for the properties window feature.

src/Files.App/ViewModels/Properties/Items · high confidence

The Settings interface has been refactored to use dedicated view models for each settings category (About, Actions, Advanced, Appearance, DevTools, Folders, General, and Layout). This change replaces the previous monolithic or less granular structure with specific view models that handle the logic and state for each distinct settings page, improving code organization and maintainability.

src/Files.App/ViewModels/Settings · high confidence

A new StickyHeaderBehavior has been added to the application's data behaviors, enabling list and grid views to keep their headers visible while scrolling. This ensures that header information remains accessible and does not scroll out of view, improving the user's ability to identify column headers during navigation.

src/Files.App/Data/Behaviors · high confidence

The application now supports preview popups from PowerToys Peek, QuickLook, and Seer Pro. The PreviewPopupService has been updated to detect and prioritize these providers in a specific order: QuickLook, then Seer Pro, then PowerToys Peek. This allows users to use their preferred third-party preview tool for file previews within the app.

src/Files.App/Services/PreviewPopupProviders · high confidence

The UI helper classes in the app have been reorganized and expanded to support new visual features and improve stability. A new \AppSystemBackdrop\ class was added to implement the 'Thin acrylic' system backdrop, allowing users to select this specific visual style for the application window. Additionally, \AppThemeResourcesHelper\ was introduced to manage and apply custom theme colors for various UI components like the address bar, toolbar, and sidebar. The \DragZoneHelper\ was added to manage title bar drag regions using \InputNonClientPointerSource\, while \SidebarSectionIcons\ was created to handle sidebar icon resolution with high-contrast mode support. Existing helpers like \UIHelpers\ and \UIFilesystemHelpers\ were refactored to support these changes, including updates to the 'Create new item' dialog and shortcut creation logic.

src/Files.App/Helpers/UI · high confidence

The app's internal architecture has been reorganized to improve code structure and maintainability. The application now utilizes a new database model for settings storage, replacing the previous implementation. Additionally, the codebase has been refactored to use a dependency injection (DI) container for managing services and components, moving away from static singletons. The app's entry point and window management have also been updated to support these architectural changes.

src/Files.App · high confidence

The application's data models, including those for app state (AppModel), drive management (DrivesViewModel), pinned folders (PinnedFoldersManager), and various UI components (ColumnsViewModel, CompressArchiveModel, etc.), have been moved into the new Files.App.Data.Models namespace. This reorganization groups these core data structures together, improving code structure and maintainability.

src/Files.App/Data/Models · high confidence

The repository has been reorganized into a modern, single-project solution structure using a .slnx file, with all projects grouped under and /tests/ directories. A new Directory.Build.props file centralizes build properties, including a target framework of .NET 10 and enabling strict Roslyn compilation. The solution now uses Microsoft.Testing.Platform for testing, and the .editorconfig enforces consistent tab-based indentation for C\# and XAML files. Additionally, the repository has switched from a GNU GPL v3 license to dual MIT and MPL 2.0 licenses, and the README has been removed.

(repo-wide) · high confidence

The Win32 helper functionality has been reorganized into separate, focused partial classes: Win32Helper.Process.cs for launching and managing processes, Win32Helper.Shell.cs for shell folder enumeration, Win32Helper.Storage.cs for file associations and icon retrieval, and Win32Helper.WindowManagement.cs for window positioning. Additionally, Win32PInvoke now explicitly defines the constants, enums, and P/Invoke method signatures previously scattered or manually defined, consolidating the Win32 interop layer.

src/Files.App/Helpers/Win32 · high confidence

The application's codebase has been reorganized to improve structure and maintainability. A new HomeViewModel has been introduced to manage the Home page's widget state and reloading logic. The main application state is now handled by a refactored MainPageViewModel, which manages the tab bar, sidebar, and background image settings. Additionally, a dedicated ReleaseNotesViewModel has been added to handle the release notes interface. These changes support the broader refactoring of the app's startup routine and dependency injection, providing a cleaner separation of concerns for the home page, main window, and release notes features.

src/Files.App/ViewModels · high confidence

The cloud drive detection logic has been restructured from a monolithic implementation into a modular system using an AbstractCloudDetector base class and individual detector classes for each provider (Box, Dropbox, Google Drive, OX Drive, Synology Drive, and a generic fallback). This change introduces a new detection pipeline where each cloud provider is handled by a dedicated class, improving maintainability and allowing easier addition of new providers in the future.

src/Files.App/Utils/Cloud/Detector · high confidence

The command management system has been refactored to support command grouping and modifiable commands. A new \CommandGroup\ abstract class and \CommandGroupManager\ introduce a structured way to organize commands into categories (e.g., 'Extract', 'SetAs', 'NewItem') with associated metadata like display names, glyphs, and access keys. The \CommandManager\ now manages these groups and handles custom key bindings, including logic to resolve duplicate key conflicts. Additionally, a \ModifiableCommandManager\ is introduced to allow specific commands (Paste, Delete, Open Properties) to have alternative behaviors or shortcuts (e.g., Shift+Delete for permanent delete).

src/Files.App/Data/Commands/Manager · high confidence

The layout views have been restructured by introducing new base classes, \BaseLayoutPage\ and \BaseGroupableLayoutPage\, which encapsulate shared logic for all layout types. Specific layouts like Columns, Details, Grid, and List now derive from these base classes, centralizing event handling, selection management, and command initialization. This change standardizes how layout pages interact with the rest of the application, improving code reuse and maintainability across the file browser's different view modes.

src/Files.App/Views/Layouts · high confidence

The codebase for the user interface controls has been reorganized into dedicated ViewModel classes. A new InfoPaneViewModel manages the details and preview pane state, while a new StatusCenterViewModel handles the progress and notification center. The sidebar logic has been split into SidebarViewModel and its partial classes (SidebarViewModel.FlatTree.cs, SidebarViewModel.TabExpansion.cs) to manage the flat tree representation and tab-specific expansion states. Additionally, a new ShelfViewModel has been introduced to manage the shelf pane, and a new NavigationToolbarViewModel has been created to handle the navigation toolbar and omnibar interactions.

src/Files.App/ViewModels/UserControls · high confidence

The widget view models (Drives, FileTags, NetworkLocations, QuickAccess, and RecentFiles) have been refactored to inherit from a new abstract BaseWidgetViewModel. This base class centralizes common context menu logic, dependency injection, and command definitions, while each specific widget now implements its own GetItemMenuItems method. This change standardizes how context menus are built for each widget type, reducing code duplication and improving maintainability.

src/Files.App/ViewModels/UserControls/Widgets · high confidence

A change to existing behaviour in src/Files.App/Assets/FilesOpenDialog — 2 commits, 2 files.

src/Files.App/Assets/FilesOpenDialog, src/Files.App/Assets/Libraries · medium confidence · unverified

A new \GlobalHelper\ utility class was added to the \Files.App.Controls\ project, providing a method to change the cursor on UI elements and a debug logging helper for the Omnibar. Additionally, a \GlobalUsings\ file was introduced to centralize global using directives for system, Microsoft UI, and shared application namespaces.

src/Files.App.Controls · medium confidence

New MSBuild publish profiles for win-arm64, win-x64, and win-x86 targets have been added to configure self-contained=false and single-file=false for Windows builds, addressing a CsWinRT issue. Additionally, launch settings have been configured to use the MsixPackage command name for local development.

src/Files.App/Properties · high confidence

The application introduces new helper classes to manage core application states and user preferences. AppLifecycleHelper now tracks launch counts, first-run status, and handles background update checks and Sentry crash reporting. AppLanguageHelper provides a centralized way to manage supported languages, detect right-to-left (RTL) support, and update the system's primary language override. Additionally, AppToastNotificationHelper replaces previous notification logic with WinUI 3's AppNotificationManager to display unhandled exception and background running notifications.

src/Files.App/Helpers/Application · high confidence

The \Generic.xaml\ file in \src/Files.App.Controls/ThemedIcon/\ has been introduced to serve as the central theme resource dictionary for the application's UI controls. This new file aggregates and merges the style definitions for a wide range of components, including ThemedIcon (with its associated styles for icons, settings, and layout), Toolbar (including buttons, separators, and toggle buttons), Storage controls (StorageRing and StorageBar), Breadcrumb, Omnibar, Sidebar, BladeView, GridSplitter, and SamplePanel. This change consolidates the visual styling of these elements into a single entry point, ensuring consistent theming across the application.

src/Files.App.Controls/Themes · medium confidence

The application now uses a new helper class, WidgetsHelpers, to manage widget availability and settings checks. This utility determines if a specific widget can be added and if its corresponding setting is enabled, handling the logic to remove widgets if they are disabled. It supports QuickAccess, Drives, NetworkLocations, FileTags, and RecentFiles widgets.

src/Files.App/Utils/Widgets · high confidence

The \StorageControlsHelpers\ class was added to \src/Files.App.Controls/Storage/StorageControlsHelpers.cs\, providing static utility methods for the \StorageRing\ and \StorageBar\ components. These helpers include functions for calculating positive modulus, interpolating thickness and angle values with optional easing, converting between double values and percentages, and calculating gap angles for circular strokes. This refactoring consolidates shared logic used by the storage controls.

src/Files.App.Controls/Storage · high confidence

The layout view model now enforces stricter checks during drag-and-drop operations, including preventing race conditions by verifying the ShellViewModel is initialized, handling drag sources from 7-zip archives, and supporting drag-to-clone functionality for Git repositories. Additionally, it now supports middle-click scrolling for folders, allows opening shortcuts in new tabs via middle-click, and manages file creation and pointer wheel events for layout size adjustments.

src/Files.App/ViewModels/Layouts · high confidence

The application now uses dedicated manager classes to handle drive detection and sidebar state. A new WindowsStorageDeviceWatcher class improves drive enumeration, specifically handling BitLocker-locked drives and fixing crashes on certain removable drives. Additionally, a QuickAccessManager class manages pinned items and the Recycle Bin pinning state, while a WSLDistroManager class handles the detection and display of WSL distributions in the sidebar. These changes support the redesigned left-hand sidebar and ensure drives without media or locked drives are handled correctly.

src/Files.App/Utils/Global · high confidence

The sidebar now uses a dedicated context class (SidebarContext) that exposes properties for the right-clicked item, whether an item is right-clicked, if it is a pinned folder, and the drive item to open. This centralizes sidebar state and enables the UI to react to selection changes.

src/Files.App/Data/Contexts/SideBar · high confidence

Added a new ContentPageContext class and its interface to centralize the state of the content page, including properties for navigation (CanGoBack, CanGoForward), selection, and pane status (IsMultiPaneAvailable, IsMultiPaneActive). This refactoring consolidates logic previously scattered across the UI and view models, providing a single source of truth for the current page's context and enabling more robust handling of UI state changes.

src/Files.App/Data/Contexts/ContentPage · high confidence

Added a new command-line parser in the Files.App project that handles Windows command-line arguments. The new implementation supports parsing arguments for opening directories, output paths, item selection, and file tagging, as well as handling shell commands and file paths. This replaces the previous command-line handling, ensuring that invalid parameters do not cause crashes and that error dialogs do not appear after updates.

src/Files.App/Utils/CommandLine · high confidence

Added a new \EventArguments\ namespace containing strongly-typed event argument classes to handle various application states and user interactions. This includes \CurrentInstanceChangedEventArgs\ for tracking active tab instances, \LayoutModeEventArgs\ and \LayoutPreferenceEventArgs\ for layout configuration changes, \MainPageNavigationArguments\ and \NavigationArguments\ for managing navigation context and search parameters, \PaneNavigationArguments\ for dual-pane navigation, \PathNavigationEventArgs\ for path-based navigation, \QuickAccessCardEventArgs\ for managing Quick Access items, \SearchBoxQuerySubmittedEventArgs\ and \SearchBoxTextChangedEventArgs\ for search interactions, \SelectedTagChangedEventArgs\ for tag selection, \SettingChangedEventArgs\ for settings updates, \ToolbarQuerySubmittedEventArgs\ for toolbar queries, and \WidgetsRightClickedItemChangedEventArgs\ for widget interactions.

src/Files.App/Data/EventArguments · high confidence

The application now uses a new \CachingJsonSettingsDatabase\ and \DefaultJsonSettingsDatabase\ implementation for storing user settings as JSON files, replacing the previous mechanism. This change introduces an in-memory cache to reduce file I/O operations, ensuring that settings are only written to disk when they actually change. The \DefaultJsonSettingsSerializer\ handles the serialization using \System.Text.Json\, and the \DefaultSettingsSerializer\ manages file creation and reading. Additionally, the code now includes robust error handling for invalid JSON data, preventing crashes when the settings file is corrupted or malformed, and gracefully falling back to default values.

src/Files.App/Utils/Serialization/Implementation · high confidence

The application's value converters have been consolidated and migrated from the legacy App.ValueConverters namespace to the new Files.App.Converters namespace. This change includes the introduction of a generic base class for value converters, the addition of new converters for handling status center states, boolean visibility toggling, and various type conversions (e.g., enum to string, double to string). This reorganization improves code structure and aligns with the broader project migration from the UWP-based 'Files.Uwp' to the new 'Files.App' architecture.

src/Files.App/Converters · high confidence

The application's Windows interop layer has been migrated from the Vanara library to the CsWin32 source generator. This change replaces manual \DllImport\ declarations and private struct definitions with generated C\# code, introducing new helper types such as \ComHeapPtr\, \ComPtr\, and \HRESULT\ extensions, while also adding manual definitions for APIs like \SetWindowLongPtr\ and specific COM interfaces (e.g., \IStorageProviderQuotaUI\, \IDetectionAndSharing\) to support AOT compatibility and improve startup error handling.

src/Files.App.CsWin32 · high confidence

The internal storage for file tags has been migrated from the LiteDB database to the Windows Registry, with new classes (FileTagsDatabase, FileTagsHelper, FileTagsManager) handling the persistence and management of tag data. This change replaces the previous database-backed approach with a registry-based one, ensuring that tag information is now stored in the Windows Registry under the 'Software\\Files Community' key, which may affect how tag data is accessed and persisted across updates.

src/Files.App/Utils/FileTags · high confidence

Added new action classes (OpenInNewTabAction, OpenInNewTabFromHomeAction, OpenInNewTabFromSidebarAction) that implement the 'Open in New Tab' functionality for different UI contexts. The base action handles standard file/folder selection in the main content page, while the home and sidebar variants specifically handle right-clicked items in those respective areas. This refactors the previous implementation into a more modular, context-aware structure using the RichCommands framework.

src/Files.App/Actions/Navigation/OpenInNewTab · high confidence

The codebase introduces three new attributes in the shared layer to support code generation and configuration. \[GeneratedRichCommand\] marks classes for generating command managers and codes, while \[GeneratedVTableFunction\] marks methods for generating COM vtable calls. Additionally, \[RegistrySerializable\] and \[RegistryIgnore\] attributes are added to control how preferences and tags are stored in the registry database.

src/Files.Shared/Attributes · medium confidence

The search functionality in the Files app has been restructured with new classes (FolderSearch, TagQueryExpression, TagTerm) that handle folder and tag-based queries. This change introduces a more robust search mechanism that supports both standard file name searches and tag-based filtering, including handling of spaces in tag names and proper exclusion of deleted items from search results.

src/Files.App/Utils/Storage/Search · high confidence

The application introduces new XAML style definitions for several UI elements, including the grid splitter, menu flyout sub-items, path icons, properties panel, shimmer effect, and status center info badges. These styles define the visual appearance and behavior of these components, such as the default grid splitter style, menu flyout sub-item templates, path icon definitions, and status center badge styles.

src/Files.App/Styles · high confidence

The Files application has refactored and restyled key interface components. The toolbar now supports customizable items and dynamic overflow menus, while the navigation toolbar features an updated design with improved history flyouts and access key handling. The status bar has been redesigned to display folder selection info, Git branch status, and an 'Open in IDE' button with a configurable flyout. Additionally, new user controls for data grid headers, file icons, and folder empty indicators have been introduced to support these UI updates.

src/Files.App/UserControls · medium confidence

The Copy and Cut file actions have been refactored to use a new \BaseTransferItemAction\ base class, which centralizes the execution logic for copy and cut operations. This change introduces shared properties such as \Category\, \AutomationId\, \AccessKey\, and \HotKey\ to both actions, standardizing how these file operations are defined and triggered within the application.

src/Files.App/Actions/FileSystem/Transfer · medium confidence

The Git functionality has been restructured by introducing a new \LibGit2Service\ class that encapsulates the LibGit2Sharp library interactions. This change moves the \Checkout\ operation and other Git operations into this new abstraction, preparing the codebase for dependency injection and future extensibility.

src/Files.App/Services/Git · medium confidence

Git helper methods have been moved into a new \IVersionControl\ abstraction, with \GitHelpers\ now delegating to a \LibGit2Service\ implementation. This change improves code structure and prepares the codebase for future configurability, while also introducing a \SemaphoreSlim\ to manage concurrent Git operations.

src/Files.App/Utils/Git · high confidence

The Status Center's internal architecture has been refactored to improve code quality and maintainability. A new helper class, StatusCenterHelper, was introduced to centralize the logic for creating status center items for copy, move, and recycle operations. The StatusCenterItem class was updated to support a speed graph for displaying processing speed, and the StatusCenterItemProgressModel was improved to handle progress reporting more robustly. These changes streamline how file system operations are tracked and displayed in the status center.

src/Files.App/Utils/StatusCenter · high confidence

The application's internal service architecture has been restructured into a modular, interface-driven service layer. New services such as DialogService, LocalizationService, ResourcesService, AppThemeModeService, ThreadingService, and various UpdateServices have been introduced to handle specific concerns like UI dialogs, theming, and update logic. This refactoring improves code organization and maintainability by separating distinct functional areas into dedicated service classes.

src/Files.App/Services/App · high confidence

The internal implementation for compressing files into archives has been refactored from a monolithic class into a structured set of new action classes: BaseCompressArchiveAction, CompressIntoArchiveAction, CompressIntoSevenZipAction, and CompressIntoZipAction. This change introduces a new abstraction layer for archive operations, utilizing a shared base class to handle context and destination logic, while each specific format (ZIP, 7Z, or generic) is handled by its own dedicated action class, improving code organization and maintainability.

src/Files.App/Actions/Content/Archives/Compress · medium confidence

The archive extraction functionality has been refactored into a new modular action system, introducing a shared base class (BaseDecompressArchiveAction) and specific action classes (DecompressArchive, DecompressArchiveHere, DecompressArchiveHereSmart, and DecompressArchiveToChildFolder). This change restructures how extraction commands are handled, separating the core logic from the UI/dialog interaction, and introduces a 'smart' extraction mode that automatically creates a child folder for the archive's contents.

src/Files.App/Actions/Content/Archives/Decompress · high confidence

The application's context menu and properties navigation logic has been reorganized into new factory classes: AppThemeResourcesFactory, ContentPageContextFlyoutFactory, LocalizedEnumDescriptionFactory, PropertiesNavigationItemsFactory, SecurityAdvancedAccessControlItemFactory, and ShellContextFlyoutHelper. This refactoring centralizes the creation of UI elements for themes, context menus, and property pages, improving code maintainability and separation of concerns.

src/Files.App/Data/Factories · high confidence

The application's context menu and app bar item generation has been refactored to support access keys (keyboard shortcuts) and improve code organization. The new \ContextFlyoutModelToElementHelper\ replaces the older \MenuFlyoutHelper\ for converting view models into UI elements, enabling access key support for shell extensions and the right-click context menu. The legacy \MenuFlyoutHelper\ is now marked as obsolete. This change also includes a fix for a crash in the Column Layout context menu and corrects label positioning for the context menu.

src/Files.App/Helpers/MenuFlyout · medium confidence

The file system dialog UI logic has been restructured into a new set of view models (BaseFileSystemDialogItemViewModel, FileSystemDialogConflictItemViewModel, etc.) to better separate concerns for conflict resolution and item display. This change introduces a more modular approach to handling file operations, including copy, move, and delete dialogs, by organizing the state and behavior of individual items and the overall dialog into distinct classes.

src/Files.App/ViewModels/Dialogs/FileSystemDialog · medium confidence

The application now uses a new set of internal classes (HotKey, HotKeyCollection, KeyModifiers, Keys, and HotKeyHelpers) to manage keyboard shortcuts. This refactoring improves the display of keyboard shortcuts in the Command Palette and ensures that empty hotkey strings do not cause crashes.

src/Files.App/Data/Commands/HotKey · medium confidence

The application's shell integration has been refactored to use the Windows SDK's generated interop types instead of the Vanara library. This change introduces new helper classes in the \Files.App.Utils.Shell\ namespace, including \ContextMenu\, \OpenWithMenu\, \PreviewHandler\, and \ShellFileOperations2\, which now manage Windows shell interactions such as context menus, file operations, and preview handlers. The \LaunchHelper\ has also been updated to skip the \USERNAME\ environment variable when launching processes to prevent execution issues, and \DetectionAndSharingHelper\ has been added to manage network discovery and sharing settings.

src/Files.App/Utils/Shell · medium confidence

The shell page implementation was refactored by introducing a new \BaseShellPage\ abstract class that consolidates shared logic for navigation, state management, and event handling. This base class is now inherited by \ModernShellPage\ and \ColumnShellPage\, replacing the previous scattered implementations. The \ModernShellPage\ was also updated with a modernized UI, including a new search header, a filter header for directory filtering, and visual states for active pane borders. These changes improve code maintainability and provide a more consistent user experience across different layout modes.

src/Files.App/Views/Shells · high confidence

The storage enumeration implementation has been refactored to improve performance and stability. The \UniversalStorageEnumerator\ was introduced to handle general storage enumeration, while the \Win32StorageEnumerator\ was updated to leverage the new \IStorageCacheService\ for display name caching. Additionally, the code was migrated from the Vanara library to CsWin32 for P/Invoke calls, and the logic for handling alternate data streams and folder size calculations was consolidated and optimized.

src/Files.App/Utils/Storage/Enumerators · high confidence

The TabBar control has been refactored to use a new \BaseTabBar\ abstract class and \ITabBar\/\ITabBarItem\ interfaces, separating the core tab bar logic from the concrete \TabBar\ implementation. This change introduces a more modular structure for managing tab states, selection, and drag-and-drop interactions, which supports future enhancements like tab cycling and split pane orientation.

src/Files.App/UserControls/TabBar · high confidence

The preview pane's internal architecture has been refactored to use a new \BasePreviewModel\ abstract class, with each file type (e.g., \TextPreviewViewModel\, \CodePreviewViewModel\, \PDFPreviewViewModel\) now inheriting from it. This change introduces a more modular approach to loading previews and details, allowing for better separation of concerns and easier maintenance. Users will experience improved stability and potentially faster loading times for various file types, as each preview type now handles its own specific loading logic within this new structure.

src/Files.App/ViewModels/UserControls/Previews · high confidence

The application's settings are now managed by a set of specialized services (e.g., \AppearanceSettingsService\, \LayoutSettingsService\, \GeneralSettingsService\) that each handle a specific category of user preferences. This change improves the organization and maintainability of the settings system, allowing for more granular control over features like the toolbar, sidebar, and file layout.

src/Files.App/Services/Settings · high confidence

The sidebar component has been refactored to support a new hierarchical and flat item model, enabling features like drag-and-drop reordering and nested tree views. A new \ISidebarItemModel\ interface and \FlatSidebarItem\ wrapper provide the data structure for sidebar items, while \SidebarDisplayMode\ introduces Minimal, Compact, and Expanded states to control the sidebar's width and visibility. The \SidebarView\ and \SidebarItem\ controls have been updated to support these new behaviors, including handling context menus, selection states, and accessibility peers for the new structure.

src/Files.App.Controls/Sidebar · medium confidence

New publish profile files for Windows (win-arm64, win-x64, and win-x86) have been added to the Files.App.Server project. These profiles configure the build to produce non-self-contained, single-file deployments (SelfContained=false, PublishSingleFile=False). This change aligns with a known issue in CsWinRT (issue \#373) that affects trimmed or self-contained builds, ensuring the server component can run as an out-of-process WinRT server for long-running background tasks without the constraints of a self-contained deployment.

src/Files.App.Server/Properties · medium confidence

The application's user interface has been updated with new and improved translations for several languages, including Afrikaans, Arabic, Belarusian, Bulgarian, Catalan, and Czech. These updates ensure that menu items, status messages, and settings labels are correctly localized for users of these languages.

src/Files.App/Strings · high confidence

The application now exposes whether the process is running with elevated (admin) privileges and whether drag-and-drop operations are permitted. This is implemented via the new IWindowContext interface and WindowContext class, which read the elevation state and drag-and-drop capability from IWindowsSecurityService and expose them as properties. The context also tracks the window's compact overlay state.

src/Files.App/Data/Contexts/Window · high confidence

Added UI test application for Files controls; Added UI test pages for BreadcrumbBar, Omnibar, Storage controls, ThemedIcon, and Toolbar; Added accessibility and UI helper classes for interaction tests; Added interaction test infrastructure for UI automation; Added interaction tests for folder operations and app initialization.

The project has been restructured to use a centralized package versioning system via a new \Directory.Packages.props\ file, which defines the versions for all NuGet packages including CommunityToolkit, Microsoft.WindowsAppSDK, and Sentry. This change is accompanied by a comprehensive update of all project files to reference these central versions, enabling consistent dependency management across the solution.

(dependencies) · high confidence

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 58.

• Code Health 59
• Architecture 78
• Maturity 61
• Readiness 62
• Security 54
• Performance 61

• 300 commits — 228 feature/other, 72 fixes

• src/Files.App — 230 commits
• (root) — 34 commits
• src/Files.App.Controls — 10 commits
• .github/workflows — 7 commits
• .github/ISSUE_TEMPLATE — 3 commits
• src/Files.App (Package) — 3 commits
• .github/FUNDING.yml — 2 commits
• src/Files.App.Launcher — 2 commits
• src/Files.Core.SourceGenerator — 2 commits
• tests/Files.InteractionTests — 2 commits
• .github/CONTRIBUTING.md — 1 commit
• .github/assets — 1 commit
• src/Files.App.OpenDialog — 1 commit
• src/Satori.targets — 1 commit
• tests/Files.App.UITests — 1 commit

• fix: Code Quality: Fix COMException in property notifications during UI teardown
• fix: Code Quality: Fix bugs in StringPropertyGenerator and StringsPropertyAnalyzer (#18161)
• fix: Code Quality: Fix main window closed state tracking
• fix: Code Quality: Fix preview pane (#18312)
• fix: Code Quality: Fix regression with toolbar performance
• fix: Code Quality: Fixed "Sponsor us on GitHub" hyperlink button in release notes page (#18680)
• fix: Code Quality: Fixed ArgumentOutOfRangeException in SetPathBoxDropDownFlyoutAsync
• fix: Code Quality: Fixed CI actions
• fix: Code Quality: Fixed COMException when showing tag write error dialog from background thread
• fix: Code Quality: Fixed NullReferenceException in FileOperationsHelpers.SetLinkIcon
• fix: Code Quality: Fixed an AOT annotation from the MVVM toolkit (#18676)
• fix: Code Quality: Fixed issue with clicking search result
• fix: Code Quality: Fixed padding in tree view (#18403)
• fix: Code Quality: Fixed shortcut (.lnk/.url) files showing wrong placeholder icon briefly (#18197)
• fix: Code Quality: Fixed toolbar button width
• fix: Code Quality: Fixes for tags widget
• fix: Fix: Disable Open In Terminal option when Terminal isn't installed (#18285)
• fix: Fix: Enabled Play action for single media file selection (#18520)
• fix: Fix: Fixed PowerToys Peek detection for custom install paths (#18374)
• fix: Fix: Fixed Status Center display when canceling extraction (#18246)
• …and 280 more

• 3 containers · 1 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.

files-community/Files 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.