JosefNemec/Playnite

This system is a comprehensive game library management application for Windows, featuring both a traditional desktop interface and a dedicated fullscreen mode optimized for gamepad navigation. It provides robust capabilities for organizing game collections, managing metadata, and integrating with third-party stores like Steam and GOG, alongside a powerful emulation system that supports a wide range of retro platforms. The platform is highly extensible, offering a rich SDK for plugins and PowerShell scripts, along with tools for theme development and automated build processes.

49 changes.

This period focused on a comprehensive architectural overhaul, migrating the codebase to a modern plugin-based design and replacing legacy components with new, modular systems. Key developments included the introduction of PowerShell scripting support, a robust backup and restore framework, and a restructured database layer with improved integrity and migration paths. The work also involved significant cleanup of obsolete providers and services, alongside the expansion of the SDK to support advanced extension capabilities and UI customization.

57 changes.

This period focused on a comprehensive architectural and visual overhaul of the Playnite desktop and standalone fullscreen applications, introducing modular XAML theming, new UI controls, and a complete ViewModel restructuring. The work established a robust SDK for plugin development, added extensive localization infrastructure, and implemented a dedicated CLI tool for managing extensions and themes.

22 changes.

This period focused on building a comprehensive emulation system, including database-driven game detection, extensive emulator profile support, and a dedicated DAT file parser. The Playnite SDK was significantly expanded with new utilities for data serialization, system information, and safe plugin UI integration, while the core application received major refactoring of its addon management, menu systems, and native API bindings.

The Playnite Toolbox now includes a template for generating Custom Library plugins, providing a complete scaffold for developers to create plugins that import games from external sources. This template includes the necessary project structure, such as the main plugin class inheriting from LibraryPlugin, a client implementation for opening the library, settings views with data binding, localization files, and the extension manifest (extension.yaml) defining the plugin type and metadata.

source/Tools/Playnite.Toolbox/Templates/Extensions/CustomLibraryPlugin · high confidence

A new command-line utility has been added to parse Libretro database (DAT) files into structured game data. This tool processes DAT files located in a specified directory and outputs the parsed results, supporting the emulation rework by providing a standardized way to ingest game metadata from the Libretro ecosystem.

source/Tools/Playnite.Utilities · high confidence

The desktop application now initializes its user interface by loading a comprehensive set of XAML resource dictionaries that define the default desktop theme, including global resources, standard and custom controls, derived styles, and main application views. This change establishes the visual foundation for the desktop client, ensuring consistent styling across components like the sidebar, top panel, and game library views.

source/Playnite.DesktopApp · high confidence

This update significantly broadens the range of supported emulation software by adding new emulator profiles for 4DO, Altirra, Azahar, BGB, BigPEmu, BlastEm, Borked3DS, Cemu, Citra, Citron, Cxbx-Reloaded, DOSBox, DeSmuME, Eden, FCEUX, FS-UAE, FinalBurn Neo, Flash Player Projector, Flycast, Fuse, GBE+, Gambatte, Gearsystem, Kega Fusion, Lime3DS, Locale Emulator, M64Py, MAME, Mednafen, Mesen, Mesen-S, Model 2 Emulator, NanoboyAdvance, Nestopia, NullDC, PCSX2, PCSXR-PGXP, PCem, PPSSPP, Project64, RAProject64, Reicast, and SwanStation. It also introduces a dedicated PowerShell import script for RPCS3 to automatically detect and import PS3 games from ISO and directory structures, and adds support for the shadPS4 emulator profile.

source/Playnite/Emulation/Emulators · high confidence

The Fullscreen App now provides a new \MainViewAPI\ class that implements the \IMainViewAPI\ interface, allowing SDK extensions to interact with the fullscreen UI state. This API exposes read-only access to the currently selected games, the active fullscreen view type (Details or List), and current sorting and grouping settings. It also enables extensions to programmatically switch between the library and game details views, apply filter presets, retrieve sorted filter presets, and toggle the fullscreen view mode. Several methods for opening dialogs or settings remain unsupported in fullscreen mode and will throw exceptions if called.

source/Playnite.FullscreenApp/Api · high confidence

The application now includes a new localization system that provides the English language interface and establishes the framework for multi-language support. This change introduces the core \LocSource.xaml\ resource dictionary containing all English UI strings, a generated \LocalizationKeys.cs\ file for type-safe string access, and initial translation files for languages such as Arabic and Bulgarian. Users will see the application interface in English by default, with the underlying structure in place to support future language packs.

source/Playnite/Localization · high confidence

Playnite now includes a standalone Fullscreen mode application (source/Playnite.FullscreenApp) that operates independently from the main desktop app. This new component provides a complete UI environment with its own resource dictionaries, custom controls, and views, while integrating with the core library database and SDK. It introduces specific features for the fullscreen experience, including background audio support, gamepad input handling via SDL2, and a dedicated action selector for launching games or managing controllers. The application also implements startup safeguards, such as safe mode support, crash detection, and restrictions on running from temporary folders or paths containing special characters.

source/Playnite.FullscreenApp · high confidence

A new online installer application has been added to the PlayniteTools suite, allowing users to download and install Playnite directly from remote mirrors. The installer features a WPF-based UI with a classic dark theme, supporting both standard and portable installation modes. It includes logic to prevent installation into restricted directories like Program Files, displays real-time download progress, and provides troubleshooting links. The tool is configured to run on .NET Framework 4.6.2 and includes a custom logging system for debugging installation issues.

source/Tools/PlayniteInstaller · high confidence

Users can now access third-party library clients (such as Epic Store or Twitch) directly through Playnite. This change introduces a new \ThirdPartyToolsList\ component that scans installed library plugins, verifies if their associated clients are installed, and exposes them as launchable tools with icons and names. The implementation includes error handling to prevent individual plugin failures from breaking the entire list, ensuring a stable user experience when launching external applications.

source/Playnite/ThirdPartyClients · high confidence

Users can now persist their metadata download preferences, such as which fields to import and which sources to use, so that these settings are retained between sessions rather than resetting to defaults.

source/Playnite/Metadata · high confidence

The CustomMetadataPlugin template in Playnite.Toolbox has been updated to provide a more complete starting point for developers creating metadata extensions. The template now includes a structured settings system (Settings, SettingsViewModel, and SettingsView) with support for saving/loading configuration and UI binding, a dedicated localization file (en\_US.xaml) for string resources, and an updated extension manifest (extension.yaml) that explicitly defines the plugin's Id, Type, and Module. This allows users to generate a plugin project that is ready for immediate configuration and UI customization without manually adding these structural components.

source/Tools/Playnite.Toolbox/Templates/Extensions/CustomMetadataPlugin · high confidence

A new MainViewAPI implementation is introduced, providing SDK consumers with programmatic access to the main window's state and actions. Users can now retrieve the currently selected games and filtered game lists, adjust desktop view preferences (such as sorting, grouping, and view type), and manage filter presets by applying them or retrieving their settings. The API also exposes methods to open the game edit dialog for single or multiple games, switch to the library view, and access the UI dispatcher for thread-safe operations.

source/Playnite.DesktopApp/Api · high confidence

A new PluginUserControl base class is introduced in the SDK, allowing extensions to supply UI elements to the game view. This control exposes a GameContext dependency property and triggers a GameContextChanged event when the context switches. Crucially, the implementation wraps the GameContextChanged callback in a try-catch block to prevent crashes if a plugin throws an exception during the context change, ensuring the application remains stable even if extension code fails.

source/PlayniteSDK/Controls · high confidence

A new template for creating Playnite extensions using PowerShell scripts has been added. This includes a module file (PowerShellScript.psm1) with stub implementations for common application and game lifecycle events (such as OnApplicationStarted, OnGameStarting, and OnGameSelected), an extension manifest (extension.yaml) defining the extension metadata, and a build include file to ensure the necessary files are packaged correctly.

source/Tools/Playnite.Toolbox/Templates/Extensions/PowerShellScript · high confidence

The Playnite SDK now exposes new capabilities for extensions, including a Notifications API to manage in-app alerts, an Addons API to list and disable plugins, and enhanced Database API methods for filtering games (including fuzzy name matching) and managing file storage. Additionally, design-time support is provided via DesignPlayniteAPI and DesignNotificationsAPI to improve plugin development experience.

source/Playnite/API · high confidence

The Playnite SDK now includes new extension methods to simplify common operations for developers. ListExtensions adds utility methods for working with collections, including converting to ObservableCollections, checking for items with or without predicates, adding items only if they are missing, and performing various string intersection and containment checks. StringExtensions introduces a GetLocalized method that automatically resolves string keys starting with 'LOC' using the SDK's ResourceProvider, streamlining the process of handling localized text in plugins.

source/PlayniteSDK/Extensions · high confidence

The Playnite SDK now includes a comprehensive set of new model classes in the \PlayniteSDK/Models\ directory to support advanced game metadata, filtering, and emulation features. Users and plugin developers can now utilize new data structures for age ratings (\AgeRating\, \AgeRatingOrg\), completion statuses (\CompletionStatus\), and game features (\GameFeature\). The SDK exposes detailed filter and sorting presets (\FilterPreset\, \SortOrder\, \GroupableField\) allowing for granular control over library views. Additionally, new models for emulation (\Emulator\, \EmulatedPlatform\, \EmulatedRegion\, \GameScannerConfig\) and game actions (\GameAction\, \TrackingMode\) provide the foundation for importing and managing emulated games, including support for custom scripts, process tracking modes, and scanner exclusions.

source/PlayniteSDK/Models · high confidence

The Playnite SDK now exposes a comprehensive set of classes in the \Playnite.SDK.Plugins\ namespace that allow plugins to integrate deeply with the application's interface and data models. Plugins can now inject custom items into the sidebar and top panel via \SidebarItem\ and \TopPanelItem\, add entries to the game and main menus through \GameMenuItem\ and \MainMenuItem\, and define custom play, install, and uninstall actions using \AutomaticPlayController\, \InstallController\, and \UninstallController\. Additionally, the SDK introduces \OnDemandMetadataProvider\ for fetching specific metadata fields on request, \SearchSupport\ and \SearchContext\ for implementing global search functionality, and \LibraryPlugin\ with properties like \CanShutdownClient\ and \HasCustomizedGameImport\ to manage library integration and import processes.

source/PlayniteSDK/Plugins · high confidence

The desktop application introduces several new UI components to enhance game management and filtering. A new GameListItem control provides a standardized view for games in list-based layouts, featuring support for async image loading, double-click to start, and context menus. The GameTaskView XAML control offers a comprehensive interface for configuring game actions, including fields for paths, arguments, working directories, and emulator profiles. Additionally, a suite of selection box controls (ComboBoxList, DdItemListSelectionBox, FilterSelectionBox, FilterEnumSelectionBox, FilterStringSelectionBox) and an ExpanderEx control have been added to improve multi-selection, filtering, and group state persistence in the settings and library views.

source/Playnite.DesktopApp/Controls · high confidence

The theme designer and extension system now supports a new set of XAML markup extensions in the \Playnite.Extensions.Markup\ namespace, allowing themes and plugins to bind directly to application resources without code-behind. \ThemeFile\ and \ThemeFileBinding\ enable resolving and binding to files within the current or default theme directory, with \ThemeFileBinding\ supporting path formatting and converters. \PluginSettings\ and \PluginStatus\ allow themes to bind to specific plugin configuration values and installation status. \PluginConverter\ enables the use of plugin-provided value converters in XAML. \Settings\ and \Api\ provide access to global application settings and the Playnite API, while \MainViewModel\ allows binding to the main application view model. These extensions handle design-time vs. run-time context automatically and support features like direct value resolution and fallback values.

source/Playnite/Extensions/Markup · high confidence

The \source/Playnite/Converters\ directory has been populated with a comprehensive suite of new value converters and markup extensions, replacing or supplementing the previous \PlayniteUI\ equivalents. This includes converters for formatting game data (such as \PlayTimeToStringConverter\ for human-readable play duration, \NullableUlongBytesSizeToStringConverter\ for storage size, and \DateTimeToLastPlayedConverter\ for last played dates), UI visibility control (\BooleanToVisibilityConverter\, \IntToVisibilityConverter\, \NullToVisibilityConverter\), and data manipulation (\ListToStringConverter\ with custom separators, \StringToUpperCaseConverter\). Several existing converters from \PlayniteUI\ (e.g., \EnumToBooleanConverter\, \BidirectionalEnumAndNumberConverter\) have been moved to this namespace and updated to implement \MarkupExtension\ for easier XAML usage. Additionally, validation rules for numeric fields (\UlongFieldValidation\, \NullableIntFieldValidation\) are now included to ensure data integrity in game edit dialogs.

source/Playnite/Converters · high confidence

Playnite now includes a new backup and restore system that allows users to selectively back up and restore specific data categories, including settings, the game library, library files (such as covers and media), extensions, extension data, and themes. The system supports automatic backup file naming with timestamps and allows users to specify a target output directory for backups. This feature is accessible via command-line arguments and the application's internal backup/restore functionality, providing a more flexible and comprehensive approach to preserving user data compared to previous methods.

source/Playnite · high confidence

The Playnite SDK now includes new collection helper classes: ComparableList and ComparableDbItemList for comparing database item collections, ObservableObject as a base class for INotifyPropertyChanged support, and RangeObservableCollection which adds efficient AddRange and RemoveRange methods to bulk-update UI bindings. Additionally, the ObservableConcurrentDictionary class has been moved into the SDK Collections folder and its internal synchronization mechanism was changed from Post to Send to ensure property change notifications are processed on the correct thread.

source/PlayniteSDK/Collections · high confidence

This change consolidates various helper methods into the \source/Playnite/Common/Extensions\ directory, introducing new capabilities for string manipulation (including SHA256 hashing and game name normalization), object cloning via JSON serialization, and process inspection. It also refactors image processing by adding support for WebP and AVIF formats, improving DPI-aware bitmap scaling, and providing utilities to convert images to icons. Additionally, it includes extensions for dictionary operations, enum descriptions, and HTTP status code checks.

source/Playnite/Common/Extensions · high confidence

This change introduces a new Playnite.Common library containing foundational utilities for the application. It includes a BindingTools class to simplify WPF data binding, a Computer class for detailed system information retrieval (including Windows version detection and hardware specs), and FileSystem helpers for robust file and directory operations (including long path support and read-only file handling). Additionally, it adds parsers for M3U and CueSheet files, checksum calculation utilities, and icon extraction tools.

source/Playnite/Common · high confidence

This update introduces several new custom controls to the Playnite UI layer, including ExtendedListView, ExtendedListBox, and ExtendedDataGrid, which provide enhanced selection handling via a bindable SelectedItemsList property. A new FadeImage control is added to support smooth background transitions with configurable blur, darkening, and animation options. The suite also includes GridEx for dynamic grid layout management, HtmlTextView for rendering game descriptions with customizable fonts and colors, HotKeyBox for inputting keyboard shortcuts, and WindowBase as a foundational window class with accessibility and hotkey support. Additionally, the legacy SearchBox and GamesImagesView controls have been removed or refactored into these new components.

source/Playnite/Controls · high confidence

The library management experience is overhauled with a new \DatabaseExplorer\ and \DatabaseFilter\ system that enables filtering and grouping by a wide range of fields including installation status, recent activity, install size, and completion status. A new \DatabaseStats\ component provides real-time library statistics (installed, hidden, favorite counts). To support these changes, the database schema is upgraded via \GameDatabaseMigration\ (moving from version 1 to 2 and 2 to 3), which converts legacy string-based references (genres, developers, etc.) into ID-based lookups and stores them in separate collections. An \InMemoryGameDatabase\ implementation is also added to support in-memory operations and testing.

source/Playnite/Database · high confidence

This change introduces the core infrastructure for a new emulation scanning and import system. It adds data models for DAT files (DatModels.cs) to map ROM metadata like serials, CRCs, and regions, and implements an EmulationDatabase layer to query SQLite-based game databases by checksum, serial, or name. The Emulation.cs file exposes the SDK API for managing built-in emulator definitions, platforms, and regions loaded from YAML configuration files. Finally, the Scanner.cs file implements the GameScanner and EmulatorScanner classes, which handle detecting installed emulators via regex matching on executable names and scanning ROM directories while respecting exclusion lists and cloud storage settings.

source/Playnite/Emulators · high confidence

The GenericPlugin template in Playnite Toolbox has been updated to include a complete scaffold for creating plugins, featuring a C\# class that implements all available lifecycle events (OnGameInstalled, OnGameStarted, OnApplicationStopped, OnLibraryUpdated, etc.), a settings view with XAML bindings, and an extension manifest (extension.yaml) that now supports the Id field. This provides developers with a ready-to-use structure for handling game and application events and managing plugin settings.

source/Tools/Playnite.Toolbox/Templates/Extensions/GenericPlugin · high confidence

The Settings window now includes dedicated sections for advanced appearance and layout configuration. Users can customize default icon, cover, and background sources, adjust font sizes and text rendering modes, and control the visibility of specific game details fields. Additionally, scroll sensitivity and smooth scrolling options are available for both Grid and Details views, while layout settings allow precise control over the position and width of filter, explorer, and details panels.

source/Playnite.DesktopApp/Controls/SettingsSections · high confidence

The scripting subsystem now exposes a unified \PlayniteScript\ base class that allows extensions to register for a comprehensive set of application and game lifecycle events (including \OnApplicationStarted\, \OnLibraryUpdated\, \OnGameStarting\, \OnGameSelected\, and \OnGameInstallationCancelled\) and to inject custom items into the game and main menus. This replaces the previous IronPython-based implementation with a managed, PowerShell-first architecture (supporting \.psm1\/\.psd1\ files) that provides a structured, event-driven interface for script authors to interact with the library and game state.

source/Playnite/Scripting · high confidence

The application introduces new configuration classes in the Settings module to support recent feature additions. AutoClientShutdownSettings allows users to configure automatic shutdown of third-party clients with grace periods and session time limits. DetailsVisibilitySettings and SearchWindowVisibilitySettings provide granular control over which game fields (such as play time, completion status, and platform) are visible in the details and search views. FilterSettings introduces a structured model for managing complex filter criteria, including support for string, enum, and ID-based filtering, while FullscreenSettings exposes options for the fullscreen interface layout and theme. Additionally, PlaynitePaths centralizes path management and variable expansion, and WindowPositions replaces the previous GenericResponse class to properly store and restore window states.

source/Playnite/Settings · high confidence

Playnite now supports game scripts and extensions written in PowerShell. This change adds a new scripting subsystem that allows developers to create plugins using the PowerShell SDK, enabling them to hook into application events (such as game start/stop, library updates, and application lifecycle) and add custom items to the main and game menus. The implementation includes a PowerShell runtime wrapper, support for interactive debugging sessions, and proper resource management for PowerShell runspaces.

source/Playnite/Scripting/PowerShell · high confidence

The Playnite SDK assembly now explicitly registers XAML namespace definitions for the \Playnite.SDK.Models\ and \Playnite.SDK.Controls\ namespaces. This allows plugin developers to reference these SDK types directly in XAML markup using the standard WPF presentation schema, simplifying the integration of SDK models and controls into plugin user interfaces.

source/PlayniteSDK/Properties · high confidence

The Playnite SDK now provides new APIs that allow extensions to detect whether the application is running in Desktop or Fullscreen mode via the \ApplicationMode\ enum, identify built-in plugins (such as Steam, Epic, and GOG libraries) through the \BuiltinExtensions\ class, and utilize dynamic game variables like \{ImageDir}\ and \{EmulatorDir}\ via the \ExpandableVariables\ class.

source/PlayniteSDK · high confidence

The Playnite SDK now provides a public API for data handling, allowing plugins to serialize and deserialize objects to and from JSON and YAML formats (including file and stream variants) with error-reporting overloads, convert Markdown to HTML, and interact with SQLite databases. These capabilities are exposed via new interfaces and static helper classes in the Data namespace, enabling plugins to manage game data persistence and formatting without relying on internal implementation details.

source/PlayniteSDK/Data · high confidence

The Playnite Toolbox utility now provides a command-line interface to generate new add-ons (desktop/fullscreen themes, PowerShell scripts, and generic/library/metadata plugins) from templates, package existing add-ons into distributable archives, and verify addon manifests for correctness. The tool enforces validation rules such as requiring a manifest file, checking API version compatibility, and ensuring unique extension IDs, while also excluding build artifacts and IDE files from packaged themes.

source/Tools/Playnite.Toolbox · high confidence

The WebView SDK now allows extensions to execute JavaScript in the main frame via the new CanExecuteJavascriptInMainFrame property and EvaluateScriptAsync method. It also introduces granular cookie management, enabling retrieval of all cookies (including SameSite attributes) and deletion of cookies by domain or regex pattern. Additionally, extensions can now intercept and read individual web view resource content as it loads using a configurable callback and filtering function, and can set a custom user agent for specific web view instances.

source/Playnite/WebView · high confidence

The implementation files for the Origin game provider (Origin.cs, WebApiClient.cs, and WebApiTypes.cs) have been deleted from the source tree. This removes the code responsible for handling Origin-specific logic, including API communication, authentication, and game data parsing, effectively discontinuing support for this provider within this code location.

source/Playnite/Providers/Origin · high confidence

The Steam library controller, which previously exposed the /api/steam/library/{userName} endpoint to fetch a user's owned games via the Steam API, has been removed from the service. This change eliminates the ability to retrieve Steam game libraries through this specific API route.

source/PlayniteServices/Controllers · high confidence

The Wikipedia metadata provider has been removed from the application. This change eliminates the functionality that previously allowed users to automatically fetch game details, such as names and box art, by scraping data from Wikipedia pages.

source/Playnite/MetaProviders · high confidence

The legacy ASP.NET Core web service implementation located in the \source/PlayniteServices\ directory has been removed. This change deletes the \Startup.cs\ configuration, \appsettings.json\ configuration files, and the \web.config\ deployment file, indicating that this specific backend component is no longer part of the main repository.

source/PlayniteServices · high confidence

The legacy Game model class has been removed from the application's data layer. This change eliminates the previous implementation of game data structures, indicating a migration to a new underlying model or architecture for handling game information.

source/Playnite/Models · high confidence

The FilterSelector, GameDetails, GamePopupMenu, GameTaskView, GamesGridView, GamesImagesView, and GamesListView controls have been removed from the application. This eliminates the previous UI components used for filtering, displaying game details, managing game tasks, and presenting game libraries in grid, image, and list formats.

source/PlayniteUI/Controls · high confidence

The About, Category Configuration, Crash Handler, First Time Startup, Game Edit, and Installed Games windows have been removed from the application. This deletion marks the end of the previous code-behind UI implementation for these core features, clearing the way for the new MVVM-based architecture.

source/PlayniteUI/Windows · high confidence

The Playnite SDK now exposes new interfaces in the Database namespace to allow plugins to interact with the game library. IGameDatabase provides access to various collections such as Games, Platforms, Features, and ImportExclusions, while IGameDatabaseAPI extends this with file storage management and buffered update capabilities (BeginBufferUpdate/EndBufferUpdate) to suppress notification events during bulk changes. IItemCollection defines the structure for these collections, including event handling for item updates and additions.

source/PlayniteSDK/Database · high confidence

The native Windows API interop layer has been reorganized into the Playnite.Native namespace, introducing dedicated classes for Gdi32, Kernel32, Ntdll, Powrprof, Psapi, Shell32, Shlwapi, User32, Winbase, Windef, Wingdi, Winnt, Wintrust, and Winuser. This refactoring consolidates P/Invoke signatures, structs, and constants required for system-level operations such as display configuration, process management, file handling, and UI interaction, while removing legacy files like NotificationCodes and GamesLoaderHandler from the UI project.

source/Playnite/Native · high confidence

The application startup entry point (App.xaml and App.xaml.cs) and associated configuration files (App.config, App.Debug.config, App.Release.config) have been removed from the PlayniteUI project. This deletion eliminates the legacy .NET Framework 4.5.2 application lifecycle, Entity Framework configuration, and static URL settings, indicating a structural shift in how the application is initialized and configured.

source/PlayniteUI · high confidence

The project has migrated from the legacy .sln format to the new .slnx format, restructuring the solution to explicitly define the x86 platform and organizing projects into Tests and Tools folders. Additionally, a new Directory.Build.props file centralizes build settings, enforcing warnings as errors in Release builds, enabling full debug symbols, and disabling the slow WinRT source generator to improve compile times.

source · high confidence

The Steam integration has been restructured from a monolithic provider implementation into a modular plugin. This change removes the legacy, tightly-coupled source files (including the custom VDF parser, API client, and settings classes) in favor of a plugin-based design, which improves maintainability and aligns with the application's broader plugin ecosystem.

source/Playnite/Providers/Steam · high confidence

The add-on update mechanism now respects a server-provided blacklist, ensuring that add-ons flagged by the service are excluded from update availability checks. This prevents users from receiving or installing updates for add-ons that have been explicitly blocked, addressing issues where certain add-ons might otherwise trigger excessive API calls or appear in update lists despite being restricted.

source/Playnite/Addons · high confidence

The FullscreenApp assembly now explicitly defines COM visibility settings, theme resource locations, and XAML namespace definitions for controls, views, markup extensions, and view models. This ensures that XAML designers and runtime can correctly resolve types within the Playnite.FullscreenApp namespace without requiring inline attribute declarations in every file.

source/Playnite.FullscreenApp/Properties · high confidence

The assembly information in Playnite has been streamlined by removing explicit version, title, and copyright attributes, which are now likely managed elsewhere. Additionally, the assembly now explicitly registers four XAML namespaces (Playnite, Playnite.Controls, Playnite.Commands, and Playnite.Behaviors) for the standard WPF presentation schema, enabling easier usage of these components in XAML markup.

source/Playnite/Properties · high confidence

The desktop application assembly has been renamed from PlayniteUI to Playnite.DesktopApp, and the AssemblyInfo.cs file now registers new XAML namespace definitions for the Controls, Views, Markup, and ViewModels namespaces. This change updates the internal assembly identity and exposes these specific namespaces for XAML usage within the desktop application layer.

source/Playnite.DesktopApp/Properties · high confidence

The Playnite.BrowserProcess component has been restructured to self-host the CefSharp browser subprocess. This change introduces a new entry point that directly invokes CefSharp.BrowserSubprocess.SelfHost, alongside configuration files that enable loading from remote sources and disable FIPS policy enforcement. This ensures the browser process runs correctly, particularly addressing potential startup crashes in portable instances.

source/Playnite.BrowserProcess · high confidence

The build process has been updated to require PowerShell 7 and introduces several new automation scripts: \VerifyLanguageFiles.ps1\ validates localization XAML files, \applyEnglishProofing.ps1\ imports proofread English text into the source localization file, \buildLocConstants.ps1\ generates C\# constants from localization keys, and \updateLocalizations.ps1\ synchronizes translations from Crowdin. The build script (\build.ps1\) now supports explicit platform targeting (x86/x64), online installer configuration, and SDK NuGet packaging, while the MSBuild configuration (\build.xml\) has been expanded to compile additional projects including Playnite.Toolbox, Playnite.DesktopApp, Playnite.FullscreenApp, Playnite.BrowserProcess, PlayniteSDK, and PlayniteInstaller. Legacy NSIS installer scripts and associated macros have been removed.

build · high confidence

The database collection layer in source/Playnite/Database/Collections has been rewritten to enforce strict referential integrity and improve data resilience. When removing metadata entities like platforms, emulators, or companies, the system now automatically cleans up orphaned references in associated games and emulator profiles. Asset management for games and platforms has been centralized, ensuring that icons, covers, and background images are properly deleted from storage when items are removed or updated. Additionally, the core ItemCollection implementation now includes a built-in repair mechanism that detects and recovers from LiteDB file corruption by falling back to a raw BSON reader, and it disables the memory cache to reduce resource usage.

source/Playnite/Database/Collections · high confidence

The default desktop theme has been restructured into a modular set of XAML resource dictionaries, separating base styles, color constants, and control templates into distinct files. This change introduces a centralized \Constants.xaml\ for managing font sizes, colors, and brushes, while custom controls like \ComboBoxList\, \FilterSelectionBox\, and \SidebarItem\ now have dedicated template definitions. Users will experience a more consistent visual design with improved theming capabilities, as the new structure allows for easier customization of individual UI components and ensures that style changes are applied uniformly across the application.

source/Playnite.DesktopApp/Themes · high confidence

The Playnite SDK now exposes richer context in game lifecycle events and introduces new event types for URI and web view interactions. The OnGameStarting and OnGameStarted events now include the specific GameAction used to launch the game, the selected ROM file for multi-ROM titles, and the started process ID (OnGameStarted). Extensions can now cancel a game launch via the OnGameStarting event. New events include OnGameStartupCancelled, OnGameInstallationCancelled, and OnGameSelected (providing old and new game selections). Additionally, a new PlayniteUriEventArgs class supports the playnite:// URI scheme, and WebViewLoadingChangedEventArgs enables monitoring web view loading states.

source/PlayniteSDK/Events · high confidence

The XAML markup extensions previously defined in the core application's model layer (IGame.cs) have been moved to the Fullscreen App's markup namespace (Markups.cs). This change reorganizes the codebase by introducing specific markup classes for the Fullscreen App context, including Api, MainViewModel, PluginSettings, Settings, SettingsBinding, ThemeFile, and ThemeFileBinding, which now inherit from their respective base classes in the Extensions.Markup namespace. This structural shift ensures that these markup extensions are correctly scoped and available for use within the Fullscreen App's theme and UI logic, addressing previous availability issues in Fullscreen mode.

source/Playnite.FullscreenApp/Markup · medium confidence

The Fullscreen App's user interface controls have been refactored into dedicated view classes (Filters, FiltersAdditional, GameDetails, GameStatus, Main) to improve code organization and stability. This change introduces a new filter panel system that supports filter presets, additional sub-filters (such as genre, developer, and completion status), and configurable sorting. It also adds support for swapping X/A and Start/Details controller button bindings on the main screen, enables optional background images on the main menu, and fixes issues where the game details view would become stuck or unresponsive after removing a game or switching filters.

source/Playnite.FullscreenApp/Controls/Views · high confidence

The Fullscreen App's user interface controls have been replaced with custom implementations (such as CheckBoxEx, ComboBoxEx, ListBoxEx, and ScrollViewerEx) to provide robust gamepad support, including confirmation/cancellation button bindings and improved keyboard focus traversal. Additionally, a new FilterPresetSelector control has been added to allow users to select and apply saved filter presets directly within the Fullscreen mode, and the game list rendering (FullscreenTilePanel) now supports smooth scrolling and asynchronous image loading.

source/Playnite.FullscreenApp/Controls · high confidence

The Fullscreen mode interface has been reorganized by introducing dedicated XAML view files for core components, including the main library screen, game details, game menu, filter panels, and various system menus (main, help, status). This change separates the visual templates and styling for these areas, providing a cleaner structure for the Fullscreen theme and supporting new UI elements such as filter presets, custom action menus, and system power options.

source/Playnite.FullscreenApp/Themes/Fullscreen/Default/Views · high confidence

The FullscreenApp/ViewModels directory has been completely rewritten to support a redesigned Fullscreen mode interface. This change introduces a new modular ViewModel structure, including dedicated view models for the main application state (FullscreenAppViewModel), game details (GameDetailsViewModel), and various menu systems (MainMenuViewModel, GameMenuViewModel, ExtensionsMenuViewModels, HelpMenuViewModel, SettingsViewModel, NotificationsViewModel, AddonsViewModel, and GameClientsMenuViewModel). It also adds a new GlobalCommands file to handle URL navigation. This refactor consolidates the logic for the main menu, game actions, extensions, settings, and notifications into a more maintainable and feature-rich codebase, enabling the new capabilities and fixes listed in the commit history (such as HDR toggling, system power actions, and improved extension support) within the Fullscreen UI.

source/Playnite.FullscreenApp/ViewModels · high confidence

Fullscreen mode has been reworked to use a suite of new, dedicated XAML windows for core interactions, including the main menu, game menu, extensions menu, game clients menu, help menu, and addon updates. These windows provide a consistent 1920x1080 layout with unified controller and keyboard input bindings (Esc/Backspace to close). The update also introduces robust crash handling: a new CrashWindow allows users to generate diagnostic packages and restart in safe mode, while an ExtensionCrashWindow specifically handles crashes caused by extensions, offering the option to disable the offending add-on. Additionally, a LicenseAgreementWindow has been added to display and accept license terms for add-ons.

source/Playnite.FullscreenApp/Windows · high confidence

The Fullscreen mode settings UI has been refactored into distinct, dedicated sections (Audio, General, Input, Layout, Menus, and Visuals) to improve navigation and clarity. Users can now configure specific aspects of the fullscreen experience in isolated panels: Audio controls for interface and background volume; General options for display selection, battery/clock status, and image scaling; Input settings for controller support, button swapping, and navigation speed; Layout adjustments for grid columns, rows, and spacing; Menu visibility toggles for system actions and extensions; and Visual customizations for themes, font sizes, and background effects.

source/Playnite.FullscreenApp/Controls/SettingsSections · high confidence

The GOG provider implementation has been significantly restructured to migrate from the legacy GOG API to a new API endpoint, which now includes the retrieval of game playtime data. As part of this migration, the provider no longer relies on an embedded Chromium browser (CefSharp) to fetch library data or login status, resolving issues related to leaking processes and crashes when internet connectivity is unavailable. The old implementation files (GOG.cs, WebApiClient.cs, etc.) have been removed in favor of this new approach.

source/Playnite/Providers/GOG · high confidence

The gamepad input subsystem has been rewritten to use SDL2, replacing the previous DirectInput implementation. This change introduces a new GameControllerManager class that provides comprehensive controller state tracking, including analog stick and trigger values, and exposes events for button presses, controller connections, and disconnections. The update also includes a new GameControllerGesture class for binding controller inputs to UI actions and moves the MouseWheelGesture class into the Input namespace to consolidate input handling logic.

source/Playnite/Input · high confidence

The web download subsystem now enforces a 15-second timeout on requests to prevent UI freezes during slow or unresponsive network connections, and introduces a custom User-Agent header for all HTTP requests. Additionally, a new capability allows retrieving HTTP response codes and headers without downloading the full file content, which improves the efficiency and stability of metadata and add-on manifest checks.

source/Playnite/Common/Web · high confidence

The main fullscreen application view now renders correctly in visual design tools like Blend and Visual Studio. A new design-time view model provides sample game data, cover images, and UI states, allowing developers to see a realistic layout of the game list, details panel, and progress indicators without running the application.

source/Playnite.FullscreenApp/ViewModels/DesignData · high confidence

The main window's design-time view now displays realistic sample data, including game covers, backgrounds, and icons, along with a pre-configured explorer panel and selected game state. This allows developers and designers to see a more accurate representation of the UI layout and styling within XAML designers like Blend, rather than seeing empty or placeholder content.

source/Playnite.DesktopApp/ViewModels/DesignData · high confidence

The SDK now includes a new LocalizedException base class that automatically resolves error messages prefixed with 'LOC' using the resource provider, ensuring proper display of localized strings under various Windows language settings. Additionally, specific exception types like ScriptRuntimeException now capture and append script runtime stack traces to error output, providing clearer diagnostics when script execution fails.

source/PlayniteSDK/Exceptions · high confidence

The desktop application's user interface and core view models have been significantly restructured. The Add-ons management experience is now consolidated into a unified window with dedicated sections for installed extensions, themes, and online browsing, including support for installing specific addon versions and viewing source repository links. A new About window provides detailed version information for the application, SDK, and Theme API, along with access to contributor lists and diagnostic package creation. The main application view model has been refactored to improve game selection handling, ensuring the correct details view is displayed and selection state is preserved, while also introducing a global search feature and improved sidebar management. Additionally, new commands and view models support enhanced library management, including bulk editing of game fields, database field management for genres and companies, and improved emulation configuration.

source/Playnite.DesktopApp/ViewModels · high confidence

The game launching infrastructure in Playnite has been restructured with the introduction of a new GameControllerFactory, which centralizes the management of Play, Install, and Uninstall controllers and exposes lifecycle events (Starting, Started, Stopped, etc.) for better integration. Concurrently, the GenericPlayController has been significantly refactored to handle emulator profiles (both custom and built-in) more robustly, including improved variable expansion for paths and arguments, better handling of long paths, and the ability to run startup scripts for emulators. This change aims to fix various issues with game and emulator startup, particularly for emulated games and those on removable drives, by providing a more stable and flexible controller architecture.

source/Playnite/Controllers · medium confidence

This update introduces a suite of new attached behaviors in the Playnite Behaviors namespace to enhance user interface interactions. Users can now experience smooth, animated scrolling in game lists and other scrollable areas, with configurable speed and sensitivity. Visibility changes for UI elements can be animated using custom storyboards for appearing and collapsing states. Additionally, the application now supports left-click context menus, automatic scrolling to the selected item in lists, and persistent expansion states for collapsible sections. Media playback can be set to loop automatically, and focus management has been improved to ensure elements are correctly focused when they become visible or bound.

source/Playnite/Behaviors · high confidence

The Fullscreen UI now uses dedicated XAML resource dictionaries to define the visual templates for filter selection interfaces. New styles have been added for database item, enum list, and string list filter selections, each providing a consistent layout with back and clear buttons alongside the filter items. Additionally, a new style for the filter preset selector introduces a horizontal scrollable list of checkboxes, featuring a visual bullet indicator and bold text to clearly show which preset is currently active.

source/Playnite.FullscreenApp/Themes/Fullscreen/Default/CustomControls · high confidence

The addon manifest system has been updated to support richer metadata and user interactions. Addon manifests now include fields for user agreements (license URLs and update dates), screenshot thumbnails and images, and community notes, allowing users to review licensing terms and see community feedback before installing. The manifest structure also distinguishes between addon types (GameLibrary, MetadataProvider, Generic, ThemeDesktop, ThemeFullscreen) and handles installer package compatibility based on API versions, ensuring that only compatible addon versions are offered for installation.

source/Playnite/Manifests · high confidence

This change introduces a suite of new ViewModel classes to standardize and enhance user-facing dialogs and background operations. Users will see improved crash reporting with the ability to add descriptions and disable problematic extensions, a new license agreement acceptance flow for add-ons, and a refined random game selector that defaults to limiting selection to the current filter. Additionally, the application now features a more robust global progress system that supports cancellation and indeterminate states, and a dedicated update installer view that displays release notes and progress during application updates.

source/Playnite/ViewModels · high confidence

The Fullscreen UI now uses a new set of default control templates for common elements including buttons, checkboxes, comboboxes, progress bars, scroll viewers, sliders, text boxes, toggle buttons, and tooltips. These styles provide a consistent visual theme with specific focus indicators, hover states, and disabled appearances tailored for the FullscreenApp interface.

source/Playnite.FullscreenApp/Themes/Fullscreen/Default/DefaultControls · high confidence

A new Generic.xaml theme file has been added to define default styles for the fullscreen application. This includes base styles for custom ItemsControlEx and ListBoxEx controls, and a template for the WindowBase class that sets the background and content presentation, establishing the foundational visual appearance for fullscreen windows.

source/Playnite.FullscreenApp/Themes · high confidence

The application now uses a new plugin and extension management system that includes better verification of extensions and themes before installation, support for installing extensions by dropping the archive file into the main window, and improved error reporting when script execution fails. The system also supports extension localizations, allows multiple Play actions, and provides better prevention from extensions causing application crashes.

source/Playnite/Plugins · high confidence

This change introduces several new extension methods to support UI template interaction and robust handling of dynamic variables in game and emulator configurations. ControlExtensions adds GetTemplateItem to retrieve named items from WPF control templates, while IProvideValueTargetExtensions and ServiceProvider provide utilities to detect template contexts during value generation. GameExtensions introduces ExpandVariables methods for GameAction and CustomEmulatorProfile, ensuring that paths, arguments, and working directories are correctly resolved with dynamic variables (such as {InstallDirName}) before launching games or emulators, addressing previous issues with variable expansion and path handling.

source/Playnite/Extensions · high confidence

The Add-ons management experience has been restructured with new dedicated views for browsing, updating, and managing installed extensions and themes. The Browse Add-ons view now features a split-pane layout with virtualized list performance, community notes, screenshot galleries, and the ability to select specific package versions for installation or reinstallation. The Addon Updates view provides a detailed progress tracker with changelogs and status indicators for available updates. Additionally, the Installed Extensions and Installed Themes views have been refined to display module information, external developer references, load errors, and compatibility warnings, while removing built-in theme uninstall options.

source/Playnite.DesktopApp/Controls/AddonsSections · high confidence

The desktop application's library interface has been restructured to support customizable scrolling and background visuals. Users can now adjust the sensitivity, speed, and smoothness of scrolling in the Details, Grid, and List views via new settings. The Grid view also introduces a zoom slider to resize game tiles. Additionally, the main library window now supports configurable background images, including options to blur, darken, and animate the background, with specific toggles for the Grid view.

source/Playnite.DesktopApp/Controls/Views · high confidence

The application's command infrastructure has been reorganized, moving generic UI commands (such as Zoom In/Out, Play Game, and Show Details) from the PlayniteUI namespace to the core Playnite.Commands namespace. Additionally, the new GlobalCommands module introduces robust handling for URL and directory navigation: it prevents crashes when opening empty or invalid URLs, correctly processes local file paths embedded in game links without incorrectly prepending 'http://', and respects custom directory open commands defined in user settings.

source/Playnite/Commands · high confidence

The desktop application's menu system has been restructured by introducing specific WPF ContextMenu controls for distinct UI areas, replacing previous inline implementations. This change adds dedicated components for the main application menu (MainMenu), game context actions (GameMenu), library filter presets (FilterPresetsMenu), group management (GameGroupMenu), and system tray operations (TrayContextMenu). It also introduces specialized settings menus for view configuration (ViewSettingsMenu, SortSettingsMenu, GroupSettingsMenu) and view selection (ViewSelectionMenu). This refactoring centralizes the logic for populating and managing these menus, ensuring consistent behavior for features like filter preset application, group collapse/expand, and tray quick-launch items.

source/Playnite.DesktopApp/Controls/Menus · high confidence

The application now uses a new factory-based architecture for creating and managing windows, introducing specific factories for crash handlers, license agreements, progress, updates, and item selection to improve stability and prevent extension-related crashes. A new WebView window has been added, featuring a Chromium-based browser with an address bar and F12 developer tools support. Additionally, window positioning and sizing logic has been rewritten to better handle multi-monitor setups, DPI scaling, and state restoration, addressing issues where windows appeared off-screen or failed to save their size.

source/Playnite/Windows · high confidence

The web interface no longer includes the Bootstrap v3.3.5 CSS files (\bootstrap.min.css\ and \bootstrap-theme.min.css\). This removal eliminates the default Bootstrap styling and glyph icons from the web UI, which will likely cause a visual regression or require replacement with a new stylesheet to maintain the intended appearance.

web · high confidence

The App.config file in the PlayniteTests project has been deleted, removing the configuration for Entity Framework 6 and SQLite data providers. This indicates that the test application no longer relies on these specific database technologies for its data access layer.

source/PlayniteTests · high confidence

The application now uses a strongly-typed CmdLineOptions class to define and parse command-line arguments (such as --start, --safestartup, --resetsettings, and --userdatadir), replacing previous manual parsing logic. This change is part of a broader refactoring that introduces the IPlayniteApplication interface and a unified PlayniteApplication base class to manage the application lifecycle, including instance mutex handling, pipe service communication for multi-instance coordination, and startup mode initialization. This centralization ensures consistent behavior for startup flags, safe mode detection, and shutdown/restart operations across the application.

source/Playnite/App · high confidence

The desktop application's user interface has been rebuilt using the new Playnite.DesktopApp.Windows namespace, introducing a suite of modernized dialog windows including About, Action Selection, Addons, Category Configuration, Crash Handler, Database Fields Manager, and Emulated Game Import. This change replaces the previous UI implementations with these new XAML-based windows, which feature updated layouts, improved keyboard navigation, and better integration with the application's theming and command systems.

source/Playnite.DesktopApp/Windows · high confidence

The Default Fullscreen theme has been restructured to support a more modular and themable design. Visual constants (colors, fonts, brushes) are now centralized in a new Constants.xaml resource dictionary, and media assets (icons, progress indicators) are defined in Media.xaml. The theme metadata has been updated to use ThemeApiVersion 2.0.0. Additionally, the game description view has been moved from a static HTML template to a theme-specific DescriptionView.html that accepts dynamic parameters for foreground color, font family, and font size, allowing for better integration with the theme's visual style.

source/Playnite.FullscreenApp/Themes/Fullscreen/Default · high confidence

The fullscreen interface now uses new derived styles for the bottom and top menu buttons, and a redesigned game list item template. Game items in the selection list now feature a scale animation when focused and display a distinct selection border with a drop-shadow effect. Additionally, uninstalled games can be visually darkened based on user settings, and game titles are shown or hidden according to configuration.

source/Playnite.FullscreenApp/Themes/Fullscreen/Default/DerivedStyles · high confidence

The services client has been refactored to use a new backend endpoint structure, replacing the previous direct Steam library retrieval with new methods for fetching Patreon patrons, diagnostic package uploads, and add-on management (listing, details, installers, and blacklist). The client now inherits from a new base class that standardizes HTTP requests and includes a 60-second timeout, and it retrieves the service URL from configuration settings while passing the current application version in request headers.

source/Playnite/Services · high confidence

The Theme API changelogs have been updated to reflect changes through version 2.10.0, documenting additions, modifications, and removals of XAML controls and views for both Desktop and Fullscreen apps. Additionally, new Visual Studio solution files (Theme.sln) have been added for the Desktop and Fullscreen theme templates to support theme development.

source/Tools/Playnite.Toolbox/Templates/Themes · high confidence

The media folder now includes new SVG logo files (black, dark, default, fullscreen, and white variants) to replace previous assets, ensuring the application branding is displayed correctly across different themes and interface states.

media · high confidence

The fullscreen theme now uses new XAML resource dictionaries to render controller button prompts for PlayStation and Xbox controllers. These changes update the visual glyphs and font mappings for buttons such as A, B, X, Y, and shoulder triggers, ensuring the correct symbols are displayed in the fullscreen interface.

source/Playnite.FullscreenApp/Themes/Fullscreen/Default/Images · high confidence

Added TestApp test harness for Playnite integration testing; Added TestPlugin to verify SDK plugin capabilities; Added UI automation tests for core application workflows; Added system and process utility tests; Added test game library plugin; Added test harness for metadata plugin field handling; Added test plugins for extension API lifecycle events; Added tests for FilterSettings serialization and SDK model conversion; Added tests for PlayTimeToStringConverter; Added tests for addon manifest package compatibility logic; Added tests for the LibraryExporter plugin; Added unit tests for HTTP downloader response code handling; Added unit tests for Playnite model classes; Added unit tests for PowerShell scripting runtime; Added unit tests for core Playnite components; Added unit tests for database collection and filtering logic; Added unit tests for database field management and game image replacement; Added unit tests for emulation scanning and database logic; Added unit tests for extension manifest parsing; Added unit tests for extension methods; Added unit tests for identifier sanitization, backup path logic, and theme changelog resolution; Added unit tests for metadata download and plugin integration; New test infrastructure and mock utilities for unit testing; Removal of Steam library integration tests; Removal of legacy database unit tests; Removed Wikipedia metadata provider tests; Removed obsolete unit tests for GOG, Origin, and Steam providers; Removed tests for ImageUrlToImageSourceConverter; Removed tests for multi-game edit object logic; Restored unit tests for the desktop application.

The embedded web view component (CefSharp) has been updated to version 151.3.240 in the new Playnite.BrowserProcess project. This upgrade ensures the application uses the latest Chromium engine features and security fixes for rendering web content.

(dependencies) · high confidence

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

• CAI 37 → 42 (+4.7)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 54 → 48 (-6.5)
• Architecture 93 → 94 (+0.9)
• Maturity 53 → 57 (+4.4)
• Readiness 51 → 47 (-4.1)
• Security 17 → 31 (+13.5)
• Performance 60 → 60 (+0.0)

• BarePragmaDisable (source/Playnite/Controllers/GenericGameController.cs)
• BarePragmaDisable (source/PlayniteSDK/Events/ApplicationEvents.cs)
• BarePragmaDisable (source/PlayniteSDK/IDialogsFactory.cs)
• BarePragmaDisable (source/PlayniteSDK/IWebView.cs)
• BarePragmaDisable (source/PlayniteSDK/WebViewModels.cs)
• Bounded contexts not declared
• Build did not complete in the analyzer
• Change coupling: DesignPlayniteAPI.cs ↔ PlayniteAPI.cs (source/Playnite/API/DesignData/DesignPlayniteAPI.cs)
• Change coupling: Filters.cs ↔ FiltersAdditional.cs (source/Playnite.FullscreenApp/Controls/Views/Filters.cs)
• Change coupling: GameDetails.cs ↔ Main.cs (source/Playnite.FullscreenApp/Controls/Views/GameDetails.cs)
• CommentedOutCode (source/Tests/Playnite.Tests/App/UpdateTests.cs)
• CommentedOutCode (source/Tests/Playnite.Tests/App/UpdateTests.cs)
• Duplicated block (10 lines × 2) (source/Playnite/Database/Collections/PlatformsCollection.cs)
• Duplicated block (10 lines × 2) (source/Playnite/Database/Collections/RegionsCollection.cs)
• Duplicated block (10 lines × 2) (source/PlayniteSDK/Models/Emulator.cs)
• Duplicated block (11 lines × 2) (source/Playnite.DesktopApp/ViewModels/AddonsViewModel.cs)
• Duplicated block (11 lines × 2) (source/Playnite/Controllers/GenericGameController.cs)
• Duplicated block (12 lines × 2) (source/Playnite.DesktopApp/ViewModels/MetadataComparisonViewModel.cs)
• Duplicated block (12 lines × 2) (source/Playnite/Themes.cs)
• Duplicated block (13 lines × 2) (source/Playnite.DesktopApp/Controls/FilterSelectionBox.cs)
• …and 64 more

• AnalyzerSeverityNone (source/.editorconfig)
• AnalyzerSeverityNone (source/.editorconfig)
• AnalyzerSeverityNone (source/.editorconfig)
• Assertions commented out: LayoutTest (source/Tests/Playnite.FullscreenApp.Tests/Controls/FullscreenTilePanelTests.cs)
• BarePragmaDisable (source/PlayniteSDK/Models/FilterPreset.cs)
• CommentedOutCode (source/Tests/Playnite.Tests/Emulators/EmulationTests.cs)
• CommentedOutCode (source/Tests/Playnite.Tests/LocalizationTests.cs)
• DeadLoopAccumulator (source/Playnite/Controllers/GenericGameController.cs)
• DeadLoopAccumulator (source/Tools/Playnite.Utilities/DatParser.cs)
• DiscardedPureResult (source/Playnite/Extensions/GameExtensions.cs)
• Documentation: no contributor guidance (README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (source/Playnite.DesktopApp/Controls/ComboBoxList.cs)
• Duplicated block (10 lines × 2) (source/Playnite.DesktopApp/ViewModels/DatabaseFieldsManagerViewModel.cs)
• Duplicated block (10 lines × 2) (source/Playnite.FullscreenApp/Controls/ButtonEx.cs)
• Duplicated block (10 lines × 2) (source/Playnite.FullscreenApp/Controls/Views/Filters.cs)
• Duplicated block (10 lines × 2) (source/Playnite/Database/Collections/PlatformsCollection.cs)
• Duplicated block (10 lines × 4) (source/Playnite.DesktopApp/Controls/GameListItem.cs)
• Duplicated block (11 lines × 2) (source/Playnite.DesktopApp/Api/MainViewAPI.cs)
• …and 240 more

• 58 commits — 46 feature/other, 12 fixes

• source/Playnite — 28 commits
• (repo) — 7 commits
• source/Playnite.DesktopApp — 6 commits
• source/Playnite.FullscreenApp — 5 commits
• source/Tools — 3 commits
• (root) — 2 commits
• build/build.ps1 — 2 commits
• source/Directory.Build.props — 1 commit
• source/Playnite.BrowserProcess — 1 commit
• source/Playnite.slnx — 1 commit
• source/PlayniteSDK — 1 commit
• source/Tests — 1 commit

• fix: Fix: Adjusted scroll speed of game description in Fullscreen mode #4356
• fix: Fix: CJK font fallback doesn't work properly (by @RevelioLog)
• fix: Fix: Cover image data not reloading properly in Fullscreen mode (by @aHuddini)
• fix: Fix: Fullscreen description focus behavior fixes (by @siegmour)
• fix: Fix: Game list confirm button ignoring the A/B swap setting (by @kanjieater)
• fix: Fix: Grouping by name doesn't use first meaningful character from game name (by @darklinkpower)
• fix: Fix: Language and theme selection not saving properly #4385
• fix: Fix: Possible crash on startup when running from portable instance
• fix: Fix: Possible crash related to gamepad input handling (by @justin-delano)
• fix: Fix: Script based emulators don't respect exclision settings (by @Dr4w)
• fix: Fixed LARGEADDRESSAWARE not being enabled
• fix: Various crash fixes and tweaks to diag package handling
• change: 10.50 version bump
• change: 10.57 version bump
• change: 10.58 version bump
• change: 10.60 version bump
• change: Actually pushed Playnite.Deps to our nuget feed
• change: Added Gearsystem emulator profile
• change: Additional tweaks to broken install detection
• change: AppVeyor image update
• …and 38 more

• Containers 1 added · 0 removed · contexts 0 added · 0 removed · edges 0 added · 0 removed

• cli:Playnite.BrowserProcess

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

JosefNemec/Playnite 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.