unoplatform/uno

This system is the Uno Platform, a cross-platform framework that enables developers to build native UI applications using XAML and C\# across Windows, Android, iOS, macOS, Linux, and WebAssembly. It provides a unified development experience by abstracting platform-specific rendering engines—such as WinUI, Skia, and WebGPU—behind a consistent API layer. The codebase includes extensive tooling for CI/CD, automated UI testing, and documentation, alongside specialized add-ins for features like media playback, authentication, and 3D graphics.

80 changes.

This period focused on the Uno Platform 7.0 release, introducing .NET 10 support, WinUI 3 OpenGL graphics, and a new Skottie-based Lottie renderer. It also established a comprehensive automated UI testing framework for the SamplesApp, featuring screenshot regression detection and extensive control validation across multiple platforms.

59 changes.

This period focused on significantly expanding UI test coverage for XAML controls, media, and animations while introducing new runtime capabilities such as Linux FrameBuffer support and MSAL integration. The work also included foundational infrastructure improvements, including a WebAssembly interop restructuring, a new logging system, and performance benchmarking for WinUI components.

75 changes.

This period focused on expanding the Skia-based runtime across all major platforms, including macOS, X11, Win32, Android, iOS, and WebAssembly, while introducing new backends like WebGPU and headless execution. The codebase underwent significant architectural shifts to decouple rendering logic into neutral, backend-agnostic APIs and modularize the build system with a new SDK and NuGet structure. Concurrently, the team enhanced developer tooling with a robust hot-reload pipeline, improved DevServer telemetry, and comprehensive accessibility support for screen readers.

A new 'BenchmarkDotNet' sample page has been added under the Performance section, featuring a custom control that allows users to discover, run, and filter benchmarks from the SamplesApp.Benchmarks.Suite namespace. The control provides a UI to trigger benchmark execution, view real-time logs, and download the resulting benchmark data as a ZIP archive containing CSV, JSON, and XML exports. It is configured to run benchmarks in-process with specific warmup and iteration counts, and includes platform-specific adjustments for iOS to avoid code generation issues.

src/SamplesApp/Benchmarks.Shared/Controls · high confidence

The Spec Kit tooling now includes a bundled Git extension that automates repository initialization, feature branch creation (with sequential or timestamp numbering), branch validation, and remote detection. It integrates directly into the specification workflow by triggering Git operations via hooks before and after core commands (such as specify, plan, and implement), and offers configurable auto-commit behavior to stage and commit changes automatically at defined stages.

.specify · high confidence

A new Help page has been added to the Samples app, providing users with a reference for keyboard shortcuts (such as Ctrl+F for search, F5 to reload, and Alt+Left/Right for navigation) and tips on using the Library, Search, Favorites, and History features.

src/SamplesApp/SamplesApp.Shared/Samples/Help · high confidence

Introduces the Uno.NUnitTransformTool, a new utility that processes NUnit XML test results. It provides two capabilities: detecting empty result files to fail builds when no tests ran, and extracting a distinct list of failed test names (stripping parameterized arguments) to a file for targeted re-execution.

src/Uno.NUnitTransformTool · high confidence

A new sample UI for the TitleBar control has been added to the shared test app, providing interactive pages to demonstrate and manually test TitleBar features such as back/pane toggle buttons, RTL layout support, icon customization, and header content.

src/SamplesApp/UITests.Shared · high confidence

New behavior classes have been added to the SamplesApp unit tests to facilitate UI testing of specific control interactions. ListViewBaseCommand enables binding commands to ListViewBase item clicks, handling command parameters and preventing memory leaks. SplitViewBehavior allows child controls (ButtonBase or ListViewBase items) to automatically open or close the parent SplitView pane via attached properties. WebViewBehavior provides a SourceString attached property to navigate a WebView to a specific HTML string, primarily for Android, iOS, and WASM platforms.

src/SamplesApp/SamplesApp.UnitTests.Shared/Controls/UITests/Views/Behaviors · high confidence

The Samples App's UI test suite now includes a set of value converters in the \Uno.UI.Samples.Converters\ namespace to support testing scenarios. These include \FromBoolToBrushConverter\ and a generic \FromBoolToObjectConverter\<T\>\ for mapping boolean states to specific objects, \FromNullableBoolToVisibilityConverter\ for controlling element visibility based on nullable booleans, \StringEmptyToVisibilityConverter\ for handling empty string states, and \StringFormatConverter\ for applying culture-aware string formatting. These utilities are available for use within the sample application's UI tests.

src/SamplesApp/SamplesApp.UnitTests.Shared/Controls/UITests/Views/Converters · high confidence

A new command-line utility has been added to validate embedded resources within .NET assemblies. Users can specify an assembly path and a list of expected or excluded resource names; the tool checks that included resources are present and excluded resources are absent, reporting success or failure via console output.

src/Uno.ResourceTrimmingValidator · high confidence

Added new benchmark suites for Windows UI XAML Dependency Properties, including simple read/write operations, property propagation, and metadata retrieval. These benchmarks have been converted to use WinUI (Microsoft.UI.Xaml) and are now part of the SamplesApp benchmarks suite.

_src/SamplesApp/Benchmarks.Shared/Suite/Windows\_UI\_Xaml\Controls/DependencyPropertyBench · high confidence

This change introduces a new media player implementation for Skia-based X11 applications, enabling video playback on Linux desktop environments. It integrates LibVLCSharp to handle media rendering within an X11 window, supporting features such as volume control, playback state management, and aspect ratio stretching (None, Fill, Uniform, UniformToFill). The implementation includes a presenter extension that bridges the Uno MediaElement with the native X11 windowing system, ensuring proper visibility and layout updates during playback.

src/AddIns/Uno.UI.MediaPlayer.Skia.X11 · high confidence

New XAML resource dictionaries have been added to the SamplesApp UI test suite to standardize styling and data conversion for test views. The \Colors.xaml\ file defines a set of application color resources (Color01–Color08) and their corresponding brushes, supporting both Default and HighContrast theme dictionaries. The \Converters.xaml\ file registers visibility converters (\FromNullableBoolToVisibilityConverter\ and \StringEmptyToVisibilityConverter\) for use in test bindings. These are merged into the main application resource dictionary (\\_Application.xaml\) to ensure consistent visual presentation during UI tests.

src/SamplesApp/SamplesApp.UnitTests.Shared/Controls/UITests/Views/Styles/Application · high confidence

A new ResourceDictionary has been added to define the default visual style for the SampleControl used in UI testing scenarios. This style establishes a consistent layout using a StarStackPanel and applies specific padding and alignment settings to the control's content, ensuring uniform appearance across test views.

src/SamplesApp/SamplesApp.UnitTests.Shared/Controls/UITests/Views/Styles · high confidence

A new GlobalAssemblyInfo.cs file has been added to the Common project to centralize assembly metadata. This file defines the product name as 'Uno', sets the company to 'Uno Platform Inc.', and configures versioning with an assembly version of 1.0.0.1 and an informational version of 2.3.888. It also includes copyright information spanning 2009-2023 and applies security transparency settings.

src/Common · high confidence

New helper classes have been added to the SamplesApp unit tests to support UI testing scenarios. These include ContentNavigationBehavior for managing navigation state, DelegateCommand implementations for command binding, and utility helpers for GridLength, Thickness, and property metadata. Additionally, SampleHelper provides a RunWhileLoaded extension method to manage async actions tied to element lifecycle events.

src/SamplesApp/SamplesApp.UnitTests.Shared/Controls/UITests/Views/Helper · high confidence

The SamplesApp now includes a complete iOS implementation, allowing users to run the sample suite on iPhone and iPad. This adds the necessary iOS-specific files: an Info.plist configuring app metadata, permissions (camera, microphone, etc.), and scene delegate settings; a SceneDelegate to handle the iOS application lifecycle; a Main.iOS.cs entry point that initializes the Uno platform host and registers the Skia drawing backend; a LinkerConfig.xml to preserve Uno.UI assemblies during trimming; and launch image assets. This enables the iOS head to build and run with the same functionality as other mobile heads.

src/SamplesApp/SamplesApp/Platforms/iOS, src/SamplesApp/SamplesApp/Platforms/tvOS · high confidence

The Uno.UI.GooglePlay add-in now supports requesting in-app reviews on Android devices. This is implemented through a new StoreContextExtension that bridges the Uno StoreContext API to the Google Play Core Review library, allowing applications to trigger the native review flow on Android.

src/AddIns/Uno.UI.GooglePlay · high confidence

The Samples App now includes a dedicated "Unit Tests Runner" page that loads the Uno.UI.RuntimeTests assembly to execute UI tests without user interaction, and a new "Wasm Http Handler" sample page that allows users to manually test HTTP requests against a configurable URL.

src/SamplesApp/SamplesApp.Shared/Samples/UnitTests · high confidence

The SamplesApp now includes a local web content package (HTML, CSS, and JavaScript) to support runtime testing of local file loading and trackpad events within WebView2. The sample page displays two divs, sets the second div's background to blue on load, and changes it to green when clicked. It also detects the host platform (Windows, Android, iOS/macOS) and sends the background color of the first div to the native host via platform-specific web message APIs.

src/SamplesApp/LinkedFiles · high confidence

A new shared benchmark project (Benchmarks.Shared) has been added to the SamplesApp, providing a suite of performance tests for XAML controls and resources. This includes benchmarks for creating and loading UI elements (such as Border, Grid, and FrameworkElement), measuring Dependency Property read/write and propagation performance, and evaluating ResourceDictionary operations. The project integrates with BenchmarkDotNet and exposes a dedicated UI page within the sample app to run these performance suites.

src/SamplesApp/Benchmarks.Shared · high confidence

A new command-line tool, FontFallbackPreprocessor, has been added to generate C\# source files containing Unicode codepoint-to-font mappings. The tool downloads font data from the notofonts and noto-cjk GitHub repositories, analyzes supported codepoints, and outputs a static class (FallbackFontMaps) with merged ranges and font weight URLs for use in Uno.UI.Composition.Drawing.

src/FontFallbackPreprocessor · high confidence

The Uno.UI.MSAL add-in now includes a TypeScript implementation for handling web-based authentication flows. This new MSAL.WebUI module provides a static authenticate method that opens a popup window for user login and monitors the redirect URL to complete the authentication process, ensuring compatibility with various screen configurations and browser environments.

src/AddIns/Uno.UI.MSAL/ts · high confidence

New benchmark classes have been added to measure the performance of setting and clearing styles on Border controls. The BorderBenchmark and FrameworkElementBenchmark files now use Microsoft.UI.Xaml types (WinUI) instead of the previous Windows.UI.Xaml references, providing specific performance data for style toggling operations in the WinUI environment.

_src/SamplesApp/Benchmarks.Shared/Suite/Windows\_UI\_Xaml\_Controls/BorderBench, src/SamplesApp/Benchmarks.Shared/Suite/Windows\_UI\_Xaml\Controls/FrameworkElementBench · high confidence

A new tool has been added to generate inline table-of-contents files for the documentation site. The generator reads the main \toc.yml\ file, extracts specific sections (currently "How-tos and tutorials" and "WinRT features"), and outputs Markdown files containing nested headers and links into a new \includes\ directory within the articles folder.

src/Uno.Docs.InlineTOCGenerator · high confidence

The sample application now includes an attached property, IsPanIntoView, which automatically scrolls UI elements into view when the on-screen keyboard appears or disappears. This behavior is implemented via the InputPanelExtensions class, which listens to InputPane Showing and Hiding events to apply a vertical TranslateTransform, ensuring that text inputs remain visible during interaction.

src/SamplesApp/SamplesApp.UnitTests.Shared/Controls/UITests/Views/Extensions · high confidence

The Uno.UI.Foldable add-in now includes Android-specific implementations for detecting and responding to foldable device states. This change introduces \FoldableApplicationViewSpanningRects\ to calculate application view rectangles when spanned across a hinge or fold using Jetpack Window Manager, and \FoldableHingeAngleSensor\ to listen for hinge angle changes via Android sensors. These components enable Uno applications on Android to adapt their layout and behavior based on the physical folding state of the device.

src/AddIns/Uno.UI.Foldable · high confidence

This change introduces the native Android Java implementation for Uno's view hierarchy and input system. It adds \UnoViewGroup\ and \UnoRecyclerView\ as the core Android view classes, implementing a custom motion event dispatching pipeline via \UnoMotionHelper\ to correctly handle pointer events, transforms, and hit-testing. The update also includes supporting classes for text rendering (\TextPaintPoolNative\, \TextPaintSpan\), UI effects (\BrushNative\, \BorderLayerRendererNative\), and scrolling (\UnoTwoDScrollView\), along with the necessary binding metadata to expose these components to the managed Uno.UI layer.

src/Uno.UI.BindingHelper.Android · high confidence

The SamplesApp now includes an Android platform target, introducing the necessary \AndroidManifest.xml\ configuration (targeting SDK 36) and \AssemblyInfo.Android.cs\ to declare required permissions such as location, camera, and storage. This addition enables the application to run on Android devices, supporting features like map controls and media access that were previously unavailable on this platform.

src/SamplesApp/SamplesApp/Platforms/Android · high confidence

The DevServer CLI now supports a new \devserver-addin.json\ manifest file for priority add-in discovery, alongside helpers for resolving workspaces via \global.json\ and \project.assets.json\. This includes a new \server.json\ MCP configuration for the Uno Platform App MCP, and utility classes for assembly versioning, NuGet cache path resolution, and process management. These changes enhance the CLI's ability to locate and load extensions and resolve the correct development environment context.

src/Uno.UI.DevServer.Cli · high confidence

The DevServer now supports a convention-based add-in discovery mechanism that scans solution target frameworks to load external assemblies, with failures isolated via a quarantine system that prevents broken add-ins from stopping the host. The AmbientRegistry has been enhanced to support atomic IDE channel updates and cross-platform process chain diagnostics, while the host now handles graceful shutdowns via Ctrl-C and stdin signals. Additionally, the project targets .NET 8 and .NET 9 via dedicated global.json configurations.

src/Uno.UI.RemoteControl.Host · high confidence

The DevServer now monitors when applications are launched and correlates them with subsequent remote-control connections, providing visibility into launch success, timeouts, and connection latency. This is powered by the new \ApplicationLaunchMonitor\ which tracks launch events (including IDE and plugin metadata) and matches them to incoming connections, while the updated \ServiceCollectionExtensions\ registers the monitor and emits structured telemetry events (e.g., \app-launch/launched\, \app-launch/connected\, \app-launch/connection-timeout\) via the \ITelemetry\ system. Telemetry output is now configurable via the \UNO\_PLATFORM\_TELEMETRY\_FILE\ environment variable and supports event prefixes for better categorization.

src/Uno.UI.RemoteControl.Server · high confidence

The Visual Studio extension now features a deterministic state machine for tracking application launches, correlating Play/Run commands with build events to provide precise timing data to the dev-server. It introduces a dynamic menu system that allows the dev-server to inject and manage commands within the VS UI, and adds an MCP server configuration file (\mcp.json\) to expose the dev-server endpoint for external tools. Additionally, the extension now forwards Visual Studio telemetry events for hot-reload status (completed, no changes, errors) to the dev-server and improves profile/target framework synchronization with debouncing logic.

src/Uno.UI.RemoteControl.VS · high confidence

The Remote Control server's Hot Reload processor now supports two distinct update paths: a new batched IDE update mode (spec 052) that forwards file edits and the hot-reload trigger to Visual Studio in a single message for intermediate-state evaluation, and a server-side Roslyn metadata update path that applies IL/metadata deltas directly via a compilation workspace. Workspace initialization now restricts multi-targeted projects to the running application's target framework, re-points compilation outputs to RID-specific paths, and recovers from missing targeting packs by running dotnet restore under the same evaluation context. Legacy per-file IDE updates remain available via an escape hatch, and the server now emits structured telemetry for hot-reload lifecycle events.

src/Uno.UI.RemoteControl.Server.Processors · high confidence

This change introduces the foundational host and input infrastructure for the new Apple UIKit Skia runtime. It adds the \AppleUIKitHostBuilder\ and \AppleUIKitHost\ to manage the application lifecycle and allow custom \UIApplicationDelegate\ overrides. The diff implements the core input handling via \TopViewLayer\ and \AppleUIKitCorePointerInputSource\, which capture native touches and wheel events and forward them to the managed UI layer. It also registers essential extensions in \ExtensionsRegistrar\, including native element hosting for \ContentPresenter\, IME composition support for \TextBox\, and native OpenGL (EAGL) and Metal rendering contexts.

src/Uno.UI.Runtime.Skia.AppleUIKit · high confidence

This change introduces the first working implementation of Lottie animations on the WebAssembly target. It adds the core TypeScript runtime (\Uno.UI.Lottie.ts\) and type definitions (\lottie-web.d.ts\) that enable developers to load, play, pause, stop, and control the progress of Lottie animations within Uno Platform apps running in the browser. The implementation supports setting animation properties such as autoplay, stretch, and playback rate, and provides methods to manage animation state and segments.

src/AddIns/Uno.UI.Lottie/ts · high confidence

This change introduces the first accessibility support for the WebAssembly Skia runtime, enabling screen reader compatibility and keyboard navigation. It adds a comprehensive accessibility subsystem including a semantic DOM tree builder, focus synchronization between XAML and the browser, live region announcements with rate limiting, and modal focus trapping for dialogs. Key components include the AccessibilityDebugger for visualizing the semantic tree during development, FocusSynchronizer for bidirectional focus management, LiveRegionManager for screen reader announcements, and ModalFocusScope for handling focus traps in dialogs. The implementation also includes specialized handling for ComboBox dropdowns as accessible listboxes, virtualized semantic regions for items controls, and various ARIA attribute mappings for proper screen reader interaction.

src/Uno.UI.Runtime.Skia.WebAssembly.Browser · high confidence

Skia-rendered Win32 applications now support screen readers and external drag-and-drop operations. The new \Win32Accessibility\ component exposes a UI Automation provider tree that mirrors the WinUI3 structure, enabling Narrator and other assistive technologies to navigate Uno UI elements. Additionally, the \Win32DragDropExtension\ implements the Windows IDropTarget interface, allowing Uno apps to receive drag-and-drop events from external sources (such as file explorers) with visual feedback via DragUI.

src/Uno.UI.Runtime.Skia.Win32 · high confidence

The Linux FrameBuffer runtime target is now available, enabling Uno applications to run directly on Linux without a display server (X11/Wayland). This change introduces a new host builder (\UseLinuxFrameBuffer\) that configures the application to use the Linux framebuffer device (\/dev/fb0\) for rendering. It includes full input support via \libinput\ for mouse, touch, and keyboard events, with keyboard mapping handled by \xkbcommon\. The host also supports hardware-accelerated rendering via KMS/DRM (GBM) as an optional fallback to software rendering, and provides configuration options for display orientation, mouse cursor visibility, and mouse wheel direction.

src/Uno.UI.Runtime.Skia.Linux.FrameBuffer · high confidence

Added a new logging adapter that bridges Uno Platform's internal logging system with Microsoft.Extensions.Logging. The implementation includes a factory and logger class that map Uno log levels to Microsoft log levels, allowing applications to route Uno logs through the standard Microsoft logging infrastructure.

src/Uno.UI.Adapter.Microsoft.Extensions.Logging · high confidence

This change adds a new headless runtime backend for Uno applications running on Skia, enabling offscreen execution without a display server. The implementation includes a \HeadlessHost\ and \HeadlessHostBuilder\ (configurable via \UseHeadless()\) that manage a dedicated event loop and rendering thread. It supports multiple windows, per-window rasterization scale configuration, and runtime resizing via \AppWindow.Resize\. The renderer uses a no-output swap chain to keep the composition and animation loops active for features like \RenderTargetBitmap\, while globally skipping visual tree painting to optimize CPU usage.

src/Uno.UI.Runtime.Skia.Headless · high confidence

The new \Uno.HotReload\ package introduces a structured hot-reload pipeline that replaces the previous ad-hoc file watching and update logic. It adds a dedicated \FileSystemObserver\ to monitor project directories while excluding build outputs and VS caches, and a \ChangesDetector\ that classifies file modifications into edits, adds, and removes against the current solution. A new \SolutionUpdater\ applies these changes to the Roslyn solution, handling document text updates, project re-evaluations (including \Directory.Build.props\), and analyzer config refreshes. The pipeline exposes a new \IHotReloadHandler\ interface invoked on every terminal outcome (Success, NoChanges, RudeEdit, Failed), allowing consumers to react to delta-independent side-effects. It also includes a \DelegateHotReloadHandler\ for legacy compatibility and a \TemporarySolutionAddDetector\ to discover newly added files.

src/Uno.HotReload · high confidence

The Uno platform now uses a new \Uno.Sdk\ to manage project builds, replacing the previous SDK structure. This change introduces a centralized MSBuild system that handles implicit package resolution, UnoFeature configuration, and platform-specific targets (such as WebAssembly, Desktop, and Windows) through a new set of props and targets files. It also adds new MSBuild properties for IDE integration, such as \UnoNotifyAppLaunch\, and provides a build schema for better IntelliSense support in Visual Studio and other IDEs.

src/Uno.Sdk · high confidence

This change introduces the new Uno.UI.MSAL add-in, providing platform-specific helpers for Microsoft Authentication Library (MSAL) integration. The add-in includes extension methods that automatically configure parent activity or window contexts for Android and iOS (UIKit) and set up the appropriate HTTP client factory for WebAssembly. It also adds a custom WebUI implementation for the WebAssembly platform to handle interactive token acquisition. Additionally, a linker definition is included to ensure the Microsoft.Identity.Client assembly is preserved during linking, and the TypeScript configuration targets ES2017 for the WebAssembly build.

src/AddIns/Uno.UI.MSAL · high confidence

A new test-comparison tool has been added to download and compare UI test artifacts from App Center and Azure DevOps. The tool fetches test runs and screenshot artifacts, compares them against previous builds using SHA-1 hashing and pixel-level diffing, and generates an HTML report of changed screenshots. It also supports posting a summary of differences as a comment on the associated GitHub Pull Request.

src/Uno.UI.TestComparer · high confidence

The new Uno.UI.XamlHost package provides the infrastructure to host UWP XAML content within Uno Islands. It includes a reflection-based metadata provider discovery system that automatically probes the application's working directory for custom XAML types, eliminating the need for manual metadata registration. The package also supplies a DesktopWindowXamlSource extension to retrieve the visual tree root and a factory for creating XAML content by type name, enabling seamless integration of existing UWP XAML components into Uno applications.

src/Uno.UI.XamlHost · high confidence

Added a new Win32MediaPlayerPresenterExtension that hosts the VLC media player within a native Win32 window on Skia-based Win32 targets. This extension manages the native window lifecycle, coordinates pointer/touch events with the Uno UI layer, and handles video visibility and aspect-ratio stretching, enabling media playback on Win32 platforms that previously lacked this native integration.

src/AddIns/Uno.UI.MediaPlayer.Skia.Win32 · high confidence

Developers can now render 3D content using OpenGL within WinUI 3 applications on Windows via the new Uno.WinUI.Graphics3DGL add-in. This change introduces a native OpenGL wrapper that manages the OpenGL context, device context, and pixel format for WinUI windows, enabling hardware-accelerated 3D graphics in Uno apps targeting the WinUI 3 desktop runtime.

src · high confidence

The Remote Control devserver now supports running in-process via a new \ServerCore\ module, allowing it to be hosted inside any .NET process without Kestrel using the \InProcessDevServer\ helper. This change also introduces a configurable limit on concurrent hot-reload workspaces (defaulting to 5); when this cap is exceeded, the oldest workspaces are disabled to reclaim memory while keeping the client connection alive. Additionally, the server now proactively closes connections that stop sending frames within 2.1 times the keep-alive interval to prevent resource leaks from dead peers.

src/Uno.UI.RemoteControl.ServerCore · high confidence

The SamplesApp now includes a new runtime test execution engine and a dedicated UnitTestsControl UI. This change adds a comprehensive set of internal classes (TestCase, TestRun, UnitTestClassInfo, etc.) to manage test discovery, filtering, and result reporting, alongside a new XAML-based control that allows users to run tests, configure options like auto-retry and content unloading, and view detailed test results directly within the application.

src/SamplesApp/SamplesApp.UnitTests.Shared/Controls/UnitTest · high confidence

The Uno.UI.Svg add-in now provides a SkiaSharp-backed SVG renderer that serves as the default when referenced, replacing the previous managed engine. This renderer draws SVGs as vectors on Skia-compatible backends for crisp scaling and includes a performance optimization that caches rasterized textures for cross-backend scenarios (such as WebGPU), rebuilding them only when the target size changes. A reflection-based bootstrap mechanism allows the host builder to register this renderer without compile-time dependencies, ensuring the framework falls back to the managed engine if the add-in is not present.

src/AddIns/Uno.UI.Svg · high confidence

This change adds a new support assembly for the Uno UI Skia Win32 runtime, introducing a comprehensive COM interop layer and DPI initialization. It provides infrastructure for managing COM objects via \ComScope\ and \GlobalInterfaceTable\, and implements \WinFormsComWrappers\ to enable managed-to-native COM callable wrappers (CCWs) for WinForms interop scenarios. Additionally, it includes a \DpiBootstrap\ module initializer that ensures the application is marked as per-monitor DPI aware (PerMonitorV2) at startup, preventing layout and coordinate issues when launched via the .NET CLI.

src/Uno.UI.Runtime.Skia.Win32.Support · high confidence

The repository now includes a set of specialized AI reviewer agents (architect, contract, jerome, operability, performance, quality, security) located in \.claude/agents/\. These agents provide structured, role-specific guidance for reviewing code changes, covering areas such as architectural fit, public API contract stability, WinUI parity, operability (logging, cancellation, async safety), performance hazards (allocations, blocking calls), solution elegance, and security vulnerabilities. This change establishes a formalized, automated review process to catch issues like layering violations, breaking API changes, and security risks before they are committed.

.claude · high confidence

The Uno platform now includes a dedicated logging foundation library (Uno.Foundation.Logging) that provides a unified logging API across all targets. This implementation introduces a LoggerFactory with thread-safe logger creation and a LogExtensionPoint that caches loggers per type using weak keys to prevent memory leaks in collectible assembly contexts. The library supports standard severity levels (Trace through Critical) and integrates with external logging providers via the IExternalLoggerFactory interface, ensuring consistent logging behavior while optimizing for scenarios like WebAssembly where assembly unloading may occur.

src/Uno.Foundation.Logging · high confidence

Lottie animations are now supported in WebAssembly (Wasm) builds. A new \lottie.js\ script has been added to the Wasm scripts directory, providing the JavaScript runtime required to parse and render Lottie JSON animations in the browser. This enables developers to use Lottie-based visual effects in Uno Platform applications targeting WebAssembly.

src/AddIns/Uno.UI.Lottie/WasmScripts · high confidence

The drawing layer now exposes a backend-agnostic API: a neutral effect graph (EffectNode) replaces backend-specific effect implementations, and a retained command-list recorder (CommandListRetainedSession) enables replayable drawing sessions. Font rendering is supported by a new coverage-table-based fallback service that maps Unicode ranges to Noto font families, ensuring characters render correctly across platforms.

src/Uno.UI.Composition.Drawing · high confidence

The build/test-scripts area now includes dedicated shell scripts to run Skia-based runtime UI tests on Android, iOS, Linux, and macOS. The Android script (android-run-skia-runtime-tests.sh) dynamically resolves the launcher activity via ADB to handle unstable Java Callable Wrapper package names, installs the app, and waits for test results. The iOS script (ios-uitest-run.sh) uses Meta's idb tool for reliable simulator app installation and manages test filtering for snapshots and automated groups. Linux and macOS scripts execute the SamplesApp DLL with runtime test arguments, capture logs, and use the NUnit transform tool to generate failure lists for pipeline retries. Local execution is supported via wrapper scripts for Android and iOS.

build/test-scripts · high confidence

Adds a new GLCanvasElement component in the Uno.WinUI.Graphics3DGL add-in, enabling developers to render 3D graphics using OpenGL and Silk.NET on supported platforms (WinUI, Skia-based targets like macOS, Windows, and WebAssembly). The element manages its own OpenGL context, framebuffer, and rendering loop, providing Init, RenderOverride, and OnDestroy hooks for custom drawing logic. It includes robust error handling, framebuffer resizing, and platform-specific adaptations (e.g., BGRA readback fallbacks, ANGLE detection).

src/AddIns/Uno.WinUI.Graphics3DGL · high confidence

This change introduces a new GitPod workspace setup (build/gitpod) that configures the environment for .NET 8.0 (via the Dockerfile) while targeting .NET 10.0 for Skia builds and .NET 11.0 for WebAssembly builds. It adds executable scripts to build the Skia and WASM samples, serve the WASM app, and run the remote control host, ensuring the workspace is ready for development without requiring manual rebuilds of the container.

build/gitpod · high confidence

The SamplesApp now includes a new 'Generated animations playground' sample that demonstrates rendering Lottie animations using the WinUI 3.0 composition backend. This sample features a UI for controlling playback (play, pause, loop, stop, progress scrubbing) and displays several pre-generated C\# animation sources—such as 'Watermelon', 'Gradient shapes', 'Lottie logo', 'Pin jump', and 'Hamburger arrow'—which are compiled from Lottie JSON files via the LottieGen tool. These generated visuals are rendered using the \AnimatedVisualPlayer\ control, providing a dedicated area to test and visualize complex vector animations on the Skia backend.

src/SamplesApp/SamplesApp.Samples · high confidence

Added a new 'Getting Started with Uno Platform and the Raspberry Pi' guide that walks users through setting up a Raspberry Pi to run a Uno application, including prerequisites, OS updates, and running the app. The guide includes a new \install.sh\ script to automate the installation of the .NET SDK and ASP.NET Runtime on the device, and demonstrates creating and running a Uno app using the \net10.0-desktop\ target framework.

doc/articles/guides/raspberry-pi · high confidence

A new command-line tool, \Uno.ReferenceImplComparer\, has been added to validate that the runtime assemblies shipped in Uno.UI NuGet packages match their public reference APIs. The tool extracts a package and compares accessible types, methods, properties, fields, and events between the reference assemblies (targeting .NET 10.0 and .NET 11.0) and the corresponding runtime assemblies. It reports errors if public members are missing from the runtime or if base types differ, while intentionally ignoring finalizers and implicit/explicit operators to allow for runtime-specific implementation details.

src/Uno.ReferenceImplComparer · high confidence

A new standalone WinUI desktop application, ResourcesExtractor, has been added to the tools directory. This utility scans the WinUI source code (specifically PhoneResource.h and localizedResource.h) and the Microsoft.UI.Xaml.dll binary to extract localized string resources. It generates .resw files for all supported languages, which are then placed in the Uno.UI project's WinUIResources directory to support localization in the framework.

tools · high confidence

This change introduces a new Skia-based runtime host for macOS, replacing the previous GTK/Silk.NET-based approach to deliver faster startup, builds, and rendering (using Metal by default). The new host provides comprehensive native platform integrations, including VoiceOver accessibility support, drag-and-drop, clipboard management, speech recognition, native element hosting, and system theme/high-contrast handling.

src/Uno.UI.Runtime.Skia.MacOS · high confidence

A new \Uno.UI.Composition.Managed\ assembly introduces a fully managed, SkiaSharp-free implementation of the drawing and imaging stack. This includes a managed geometry engine (\ManagedGeometry\) supporting boolean operations, strokes, and flattening; a managed font provider (\ManagedFontProvider\) that indexes system fonts and parses TrueType/CFF outlines and COLR color layers; and managed image decoders for BMP, GIF, JPEG, and PNG. These components allow applications to render text, geometry, and images without relying on SkiaSharp, providing a backend-neutral path for platforms where Skia is unavailable or undesirable.

src/Uno.UI.Composition.Managed · high confidence

A new sample application demonstrating Uno Islands integration has been added. It features a WinUI 3-based host (App.xaml) that embeds Uno Platform XAML content via XamlApplication, enabling features like ToolTips and ContentDialogs within the islands. The sample includes MainPage and SecondPage with data binding, text input, and navigation, alongside a WinForms host application to demonstrate the islands in a desktop context.

src/SamplesApp/UnoIslands.Shared · high confidence

The Uno Platform now ships dedicated \Uno.Foundation\ and \Uno.WinRT\ NuGet packages, replacing the previous monolithic structure. These packages provide core runtime assemblies for .NET 10 and .NET 11 across iOS, Android, tvOS, and WebAssembly targets. \Uno.WinRT\ includes the \Uno.UI.Dispatching\ assembly and depends on \Uno.Foundation\, while \Uno.Foundation\ provides the base runtime for Skia and WebAssembly. This change introduces a new modular packaging layer that separates foundational runtime components from the main UI framework.

build/nuget · high confidence

This change introduces a new spell-checking add-in for Uno.WinUI applications. It embeds the WeCantSpell.Hunspell library and includes the English (US) dictionary and affix files as embedded resources. The implementation provides a \SpellCheckingService\ that exposes the \ISpellCheckingService\ API, enabling spell checking and suggestion generation for text inputs within the Uno platform.

src/AddIns/Uno.WinUI.SpellChecking · high confidence

The Uno.WinRT library now includes implementations for several Windows Runtime namespaces, enabling cross-platform access to core app lifecycle and system services. App activation is supported via the \Windows.ApplicationModel.Activation\ namespace, providing enums like \ActivationKind\ and classes such as \LaunchActivatedEventArgs\ and \ProtocolActivatedEventArgs\ to handle how the app is launched. Calendar integration is available through \Windows.ApplicationModel.Appointments\, including \AppointmentManager\ and \AppointmentStore\ for Android to read and manage calendar events. Background execution capabilities are exposed via \Windows.ApplicationModel.Background\, featuring triggers like \SystemTrigger\ and \TimeTrigger\, along with registration classes. Additionally, phone call history access is implemented in \Windows.ApplicationModel.Calls\, allowing apps to read call logs and manage call history entries on Android and iOS.

src/Uno.WinRT · high confidence

This change introduces the initial implementation of the Skia-based X11 runtime for Uno Platform. It provides a complete host builder pipeline (\UseX11\) that supports hardware-accelerated rendering via Vulkan, OpenGL, or OpenGLES, with a software fallback. The runtime includes full native input handling, supporting mouse, keyboard, and multi-touch via the XInput extension, as well as smooth scrolling. It also implements native clipboard monitoring and content transfer using XFixes, and supports drag-and-drop operations between the application and other X11 windows. Additionally, it features Input Method Editor (IME) support for complex text entry via D-Bus (IBus/Fcitx) and allows configuration of rendering backends, frame rates, and text shaping libraries.

src/Uno.UI.Runtime.Skia.X11 · high confidence

A new command-line utility has been added to validate XAML trimming behavior by comparing linker hints embedded in an assembly against an external hints file. Users can now verify that specific trimming configurations are correctly applied by providing a target assembly and a hints file, receiving a success or failure status based on whether the embedded hints match the expected values.

src/Uno.XamlTrimmingValidator · high confidence

The Uno.Analyzers package now includes several new diagnostic rules to catch common issues at compile time. UNO0006 warns when a XAML code-behind class (Application or DependencyObject) fails to call InitializeComponent in its constructor. UNO0002 prevents developers from calling Dispose on native views (like UIKit.UIView), which can cause runtime crashes, while allowing base.Dispose calls within overridden Dispose methods. UNO0007 detects missing NuGet package references for specific components, such as requiring Uno.UI.Lottie when using ProgressRing or Uno.UI.MediaPlayer.WebAssembly when using MediaPlayerElement on WebAssembly. Additionally, the existing UNO0001 (not implemented) analyzer has been rewritten to use IOperation, expanding support to method references, typeof expressions, and events, and ensuring diagnostics are reported for generated code.

src/Uno.Analyzers · high confidence

This change introduces a new set of build scripts and configuration files to support the project's CI/CD and development workflows. Key additions include \Install-Tizen.ps1\ and \Install-WindowsSdkISO.ps1\ for automating the installation of the Tizen SDK and Windows SDK respectively, and \sign-package.ps1\ for NuGet package signing via Azure Key Vault. The \PackageDiffIgnore.xml\ file is added to manage public API breaking changes across versions, while \cSpell.json\ and \.markdownlint.json\ configure spelling and documentation linting. Additional utilities like \copy-winui-styles.ps1\ for importing WinUI theme resources, \run-api-sync-tool.cmd\ for WinAppSDK synchronization, and \TestLocalBuild.CMD\ for local build verification are also included.

build · high confidence

Added a new set of XAML resource dictionaries in the Samples app's UI test styles folder to define consistent visual appearances for core controls. This includes custom styles for Buttons (including an animated icon variant), ListViews, ListItems, RadioButtons, ToggleButtons (specifically for the hamburger menu), TextBlocks (with a typography scale), TextBoxes (with a search variant), and Path icons (for navigation and actions like reload, favorite, and runtime tests). These styles are merged into a central \_Controls.xaml file to provide a unified look and feel for the sample application's interface.

src/SamplesApp/SamplesApp.UnitTests.Shared/Controls/UITests/Views/Styles/Controls · high confidence

The documentation site now includes a complete local development environment and build pipeline. A new Gulp-based workflow (gulpfile.js) handles CSS/JS bundling, minification, and live-reload serving via BrowserSync. The DocFX configuration (docfx.json) is established with specific template and search settings. Supporting scripts manage external documentation imports (import\_external\_docs.ps1), LLM-friendly content generation (generate-llms-full.ps1), and local validation (import\_external\_docs\_test.ps1). Standard configuration files like .gitignore, .nvmrc, and .browserlistrc are added to support the build process.

doc · high confidence

Developers can now launch the project in GitHub Codespaces using a new isolated dev container environment. This setup includes a .NET 10 SDK base, pre-installed tools like Claude Code, Uno Platform checkers, and a custom zsh shell. A key behavioral change is the introduction of a DNS-based firewall (using dnsmasq) that restricts network access to a specific allowlist of domains (e.g., GitHub, NuGet, Anthropic), blocking all other outbound DNS resolution to enhance security. The container also automatically configures Claude Code with specific MCPs (uno, uno-app) and sets up a custom status line, providing a pre-configured, secure sandbox for agent-assisted development.

.devcontainer · high confidence

The \Uno.UI.RemoteControl.Messaging\ library has been introduced to centralize the protocol and transport abstractions for the development server. It defines the \IFrameTransport\ interface and an \InProcessFrameTransport\ implementation, enabling the dev-server to operate independently of the underlying transport mechanism (such as WebSockets or in-process queues). The library also establishes the \IDEChannel\ contract, providing a structured message system for IDE integration, including hot-reload events, file updates, and development environment status notifications. Additionally, it includes \DevServerDiagnostics\ to manage diagnostic sinks safely across collectible AssemblyLoadContexts, preventing memory leaks during app teardown.

src/Uno.UI.RemoteControl.Messaging · high confidence

The SamplesApp now features a redesigned sample browser and testing framework. Users can browse samples via a new \SampleChooserControl\ that supports categories, favorites, recent items, and search. The \SampleAttribute\ replaces the previous \SampleControlInfoAttribute\ to mark test controls, adding support for manual testing flags, snapshot test exclusions, and ViewModel injection. A new \SampleInfoControl\ displays sample details, including a direct link to the source code on GitHub. Additionally, a custom \StarStackPanel\ is introduced to handle flexible layout sizing for sample items, and keyboard accelerators allow quick navigation between samples.

src/SamplesApp/SamplesApp.UnitTests.Shared/Controls/UITests/Views/Controls · high confidence

A new solution template named 'uno53AppWithLib' has been added to the 5.3 release, providing a complete project structure for applications that include a shared library. This template includes platform-specific entry points for Android, Desktop (Win311/X11/Linux/MacOS), and WebAssembly, along with standard assets like icons and splash screens. It is configured to use the \Uno.Sdk.Private\ version 5.2.0-dev.2002 and references development versions of Uno extensions and toolkits (e.g., UnoToolkit 5.2.0-dev.44). The template also introduces centralized package version management via \Directory.Packages.props\ and enforces strict coding standards through a comprehensive \.editorconfig\ and \Directory.Build.props\ settings.

src/SolutionTemplate · high confidence

The Uno documentation template has been updated with a new visual style, including a redesigned header and navbar that now loads the menu from the Uno platform website. A key addition is a fixed 'Send feedback' box in the bottom-right corner, which intelligently hides itself when it overlaps with the article content, footer, or table of contents to prevent obstruction. The layout also features improved mobile responsiveness, with scrollable menus and adjusted spacing for smaller screens, alongside updated styling for alerts, tables, and breadcrumbs.

doc/templates/uno/component · high confidence

The repository is initialized with foundational configuration files that establish the development environment and continuous integration workflows. This includes Azure DevOps pipeline definitions (.vsts-ci.yml, .vsts-ci-docs.yml) targeting .NET 11.0 and 10.0, a GitPod configuration for cloud-based development, and a Mergify policy for automated pull request merging. Additionally, the project sets up code quality standards via .editorconfig and .globalconfig, defines exclusion paths for static analysis in .codacy.yml, and provides essential contributor documentation including CONTRIBUTING.md, CODE\_OF\_CONDUCT.md, and AGENTS.md for AI-assisted development.

(repo-wide) · high confidence

The SamplesApp now includes localized resource files (.resw) for English (en-US, en), Spanish (es-ES, es-MX), French (fr-CA, fr), and Serbian (sr). These files provide translated text for the application name, description, publisher display name, and various UI sample strings, enabling the app to display content in the user's preferred language.

src/SamplesApp/SamplesApp.Shared/Strings · high confidence

The Skia runtime now includes a process-wide AccessibilityRouter that centralizes framework accessibility registrations and dispatches events to per-window instances, improving screen reader reliability and focus recovery. Additionally, the runtime adds a new Vulkan backend with platform-specific surface factories and device management, enabling hardware-accelerated rendering on supported platforms alongside the existing OpenGL path.

src/Uno.UI.Runtime.Skia · high confidence

The Uno documentation template now displays a clickable SDK version badge in the sub-navigation area, which dynamically fetches the latest stable and development versions from the NuGet API and caches them in local storage. Clicking this badge opens a modal dialog providing instructions for updating the Uno SDK, implemented using DOM manipulation to prevent XSS vulnerabilities. The template also includes responsive styling to handle badge visibility and overlap with breadcrumbs, along with new SCSS variables for GitHub-style alert colors and a structured JavaScript entry point for rendering documentation components.

doc/templates/uno · high confidence

The documentation site now includes Algolia DocSearch for improved content discoverability, replacing the previous search implementation with a modern, client-side search experience. Additionally, Mermaid.js support has been added to allow users to render diagrams and visualizations directly within documentation pages. The site also integrates Google Tag Manager for analytics tracking and introduces an 'easy-copy-code' feature to simplify copying code snippets. These changes are implemented via new template partials for the navbar, footer, scripts, and tag manager, ensuring a consistent and enhanced user experience across all documentation pages.

doc/templates/uno/partials · high confidence

The WebGPU rendering backend now uses the standard modern webgpu.h C API instead of the previous Silk.NET-based implementation. A new Python script (gen\_webgpu.py) automatically generates the C\# interop layer (enums, structs, and DllImport functions) from the wgpu-native headers (version v29.0.1.1), ensuring type-safe bindings for the native library. This change introduces new core components for the WebGPU pipeline, including a PathTessellator for analytic anti-aliasing, a WebGpuCommandRecorder for capturing drawing operations, and a WebGpuCoverage system with an atlas for efficient mask caching.

src/Uno.UI.Composition.WebGpu · high confidence

The \src/Uno.Foundation\ project now provides a standalone implementation of core Windows.Foundation types, including \PropertySet\, \StringMap\, \ValueSet\, and \IObservableVector\. This change introduces a new assembly structure with explicit \InternalsVisibleTo\ grants to \Uno.UI\ and related runtime projects, and adds a \CI\ debugging utility to support assertion checks in CI builds.

src/Uno.Foundation · high confidence

The Skia rendering backend has been extracted from Uno.UI.Composition into its own assembly (src/Uno.UI.Composition.Skia). This change removes the SkiaSharp dependency from the core composition assembly, replacing it with a neutral, backend-agnostic drawing seam (IDrawingFactory, IDrawingSession, IGeometry) that the Skia backend implements. Users benefit from a cleaner separation of concerns, reduced coupling in the core library, and the ability to swap or extend rendering backends without pulling in SkiaSharp unless the Skia backend is explicitly used.

src/Uno.UI.Composition.Skia · high confidence

The Android Skia runtime has been reorganized into a new host architecture that introduces optional Vulkan hardware acceleration (configurable via UseVulkan) with an OpenGL fallback, while also fixing accessibility compatibility with AndroidX.Core 1.17 through JNI-based method probing and adding a new ExploreByTouchHelper implementation for screen reader support.

src/Uno.UI.Runtime.Skia.Android · high confidence

The CI pipeline now includes a new script to check the status of the master branch build, blocking PR merges if the master has been failing for more than 24 hours (treating NuGet publish failures as non-blocking). A new script determines which optional test stages (template tests and screenshot comparisons) should run based on changed files, reducing unnecessary CI load. Additionally, a validation script ensures that packages listed in packages.json exist on NuGet.org and that pinned Xamarin package dependencies are coherent, with warning-only mode for non-master branches to allow testing against unreleased packages.

build/ci/scripts · high confidence

The Uno.UI.Composition assembly has been refactored to decouple composition logic from the Skia backend by introducing a neutral drawing seam (IDrawingSession, IGeometry, etc.), allowing the SkiaSharp dependency to be dropped from this project and moved to the runtime-specific Skia assembly. This change enables new capabilities such as the AcrylicMaterialBrush (rendered via a neutral effect tree), AnimationController for keyframe scrubbing, and BorderVisual for improved border/background rendering, while also upgrading the underlying graphics library to SkiaSharp 4.148.

src/Uno.UI.Composition · high confidence

The documentation search experience has been refined to prevent confusion when multiple pages share the same title (e.g., 'Get Started' for XAML vs. C\#). The new client-side transform logic detects these duplicates and appends a distinguishing suffix (such as '— Xaml') to the search result titles. This logic is designed to preserve existing search highlight markup and safely handle edge cases like short URLs or special characters. Additionally, the search interface styling has been updated to match the Uno platform theme, and heading anchor links are now visible only on hover to reduce visual clutter.

doc/templates/uno/service · high confidence

The documentation has been updated to reflect the Uno Platform 7.0 release, including migration guides for breaking changes such as the removal of Mac Catalyst, WPF target support, and legacy XAML prefixes. It also covers the transition to .NET 10, detailing new project templates, updated publishing instructions, and adjustments to the supported features list. Additional content includes guidance on Uno Platform Studio, MCP (Model Context Protocol) integration, and various IDE-specific setup steps for Visual Studio, Rider, and VS Code.

doc/articles · high confidence

The UI test framework now includes an AutoRetry attribute that automatically reruns flaky tests on failure, reducing false negatives in CI. Screenshot comparisons have been significantly improved with the new ImageAssert, which supports pixel-level tolerance, device scaling adjustments, and detailed failure reporting to help diagnose visual regressions.

src/SamplesApp/SamplesApp.UITests/TestFramework · high confidence

The Uno.UI.FluentTheme package now includes the V2 Fluent theme resources, which align the visual appearance of controls (such as TextBlock, AcrylicBrush, and CornerRadius) with the latest WinUI 3 specifications. This update introduces a new MSBuild pipeline (FluentMerge.targets) that automatically merges these XAML resources into a single themeresources.xaml file at build time, ensuring the theme is linker-friendly and trimmable. Additionally, compact density styles for Date/Time pickers and NavigationView are now available as separate, opt-in resources, and the assembly metadata has been updated to support modern runtime identifiers and trimming.

src/Uno.UI.FluentTheme · high confidence

The Hot Reload client in Uno.UI.RemoteControl now allows developers to pause visual tree updates during file changes to prevent flickering, and automatically reconnects to the DevServer if the WebSocket connection is dropped. Additionally, the client exposes an API to force-save files to disk during hot reload sessions, improving reliability when editing in-memory.

src/Uno.UI.RemoteControl · high confidence

The Algolia crawler configuration for the documentation site has been updated to fix search quality issues. Duplicate search results caused by multiple headings on a single page are resolved by changing the deduplication key to \url\_without\_anchor\. Site chrome elements (navbar, footer, sidebar, breadcrumbs) are now excluded from indexing to prevent irrelevant matches. Additionally, URL normalization ensures that tabbed pages (via \?tabs\ query strings) and alternative URL forms (trailing slashes, \index.html\) are indexed as single, clean entries, resulting in more accurate and concise search results.

doc/algolia · high confidence

The Uno.UI.Lottie add-in now includes a new Skottie-based rendering engine (SkottieLottieRenderer) that replaces the previous implementation, enabling Lottie animations to be rendered via SkiaSharp's Skottie library. This change introduces a neutral ILottieRenderer seam and includes explicit registration of the Lottie renderer on iOS and tvOS platforms to ensure proper discovery in trimmed or AOT-compiled scenarios. Additionally, the TypeScript configuration for the WebAssembly component has been updated to target ES2017, and a new Utf8StringStream utility is provided to efficiently handle JSON payloads without full materialization.

src/AddIns/Uno.UI.Lottie · high confidence

The Uno.UI.Dispatching library now uses a new NativeDispatcher implementation to handle UI thread dispatching, replacing previous mechanisms with platform-specific schedulers for Android (using Choreographer), iOS/macOS (using CoreFoundation dispatch queues), and WebAssembly (using JavaScript interop). This change ensures that dispatcher operations are enqueued on the main thread using native platform primitives, improving threading reliability and performance across supported targets.

src/Uno.UI.Dispatching · high confidence

The Samples app's UI test presentation layer has been refactored to use a new \SampleChooserViewModel\ split across multiple partial files (Commands, Properties, UWA, Skia). This change introduces explicit command bindings for navigation (previous/next section), sample management (favorites, recents, search), and test execution (record all tests, open runtime tests, create new window). It also adds platform-specific view hierarchy printing for debugging and storage folder management, ensuring the UI test chooser behaves consistently across WinUI, Skia, and UWA targets.

src/SamplesApp/SamplesApp.UnitTests.Shared/Controls/UITests/Presentation · high confidence

The SamplesApp WebAssembly platform now includes a dedicated entry point (Program.cs) that initializes the Uno platform host and integrates with the shared drawing backend configuration, enabling runtime selection of rendering backends (such as WebGPU) via URL query parameters. A new linker configuration (LinkerConfig.xml) ensures critical assemblies like Uno.UI, Microsoft.Extensions.Logging, and IdentityModel are preserved during publishing, while an updated AppManifest.js defines the application's splash screen and display name.

src/SamplesApp/SamplesApp/Platforms/WebAssembly · high confidence

This change introduces a new \X11NativeWebView\ implementation for the Uno Platform on Linux, replacing the previous approach with a GTK\# and WebKitGTK-based solution. The new provider registers itself via \ApiExtension\ for Linux environments and initializes a dedicated background thread to run the GTK application loop. It embeds the WebKit webview into the application's native window hierarchy, handling X11 window IDs (XIDs) for seamless integration. Key behavioral improvements include disabling GDK frame synchronization to prevent rendering freezes under certain window managers (like Mutter/GNOME) and ensuring the webview window is undecorated. The implementation also hardens thread safety by guarding GTK calls against the main thread and handles library loading for WebKit2GTK 4.1 to support modern features like HTTP header access.

src/AddIns/Uno.UI.WebView.Skia.X11 · high confidence

The documentation site now uses a new master layout template (\_master.tmpl) that structures the page with a navbar, breadcrumb, and SDK version badge. The SDK version badge includes specific keyboard handling to prevent page scrolling when the spacebar is pressed, ensuring a smoother user experience. The layout also integrates Google Tag Manager for analytics and includes standard assets like styles, fonts, and the favicon.

doc/templates/uno/layout · high confidence

The build system now includes a set of new solution filter files in \build/filters\ (e.g., \Uno.UI-packages-all.slnf\, \Uno.UI-packages-skia.slnf\, \Uno.UI-packages-wasm.slnf\) that explicitly define which projects are included for various packaging scenarios. These filters point to the new \.slnx\ solution file and group projects by target platform (Skia, Wasm, netcoremobile, Reference, Windows), ensuring that CI and packaging processes build only the necessary components for each specific backend or feature set.

build/filters · high confidence

The documentation template has been updated to fetch the main navigation menu dynamically from the Uno Platform WordPress API, replacing the previous static menu structure. This change introduces a new search implementation using Lunr.js for local full-text search with partial word matching, and adds a 'Send feedback' link that automatically targets the correct GitHub repository based on the current URL path. The layout now includes improved handling for code tabs, anchor visibility on hover, and responsive adjustments for mobile headers and table of contents heights.

doc/templates/uno/styles · high confidence

The SamplesApp project has been renamed from SamplesApp.Head to SamplesApp. This change includes the addition of platform-specific configuration files: a GlobalUsings file for Windows that imports Microsoft.UI namespaces, an app.manifest for Windows that sets DPI awareness to PerMonitorV2 and declares compatibility with Windows 10 features, and an Info.plist for macOS that defines the app bundle details, including display name 'Uno Samples (Skia)', identifier, and permissions for microphone and speech recognition access.

src/SamplesApp/SamplesApp/Platforms/Windows, src/SamplesApp/SamplesApp/Resources · high confidence

The SamplesApp project now includes the Package.appxmanifest and app.manifest files, restoring the application's identity and package configuration for Windows deployment. Additionally, the app.manifest explicitly enables PerMonitorV2 DPI awareness, ensuring the application renders correctly on high-DPI displays across different Windows versions.

src/SamplesApp/SamplesApp · high confidence

The SamplesApp desktop entry point (Program.cs) has been updated to initialize the Uno Platform host with support for multiple rendering backends. Users can now run the sample app on Linux via X11 (with configurable Vulkan/OpenGL/OpenGLES/Software rendering via the UNO\_X11\_RENDERER environment variable), Windows via Win32 (with configurable Vulkan/OpenGL/Software rendering via the UNO\_WIN32\_RENDERER environment variable), Linux Framebuffer (with specific keyboard layout configuration), and macOS. The entry point also ensures proper assembly loading for Skia dependencies and registers native WebView2 providers for X11 environments.

src/SamplesApp/SamplesApp/Platforms/Desktop · high confidence

The SamplesApp now includes a dedicated drawing backend configuration that explicitly registers graphics, font, image, and SVG providers for iOS, tvOS, and SkiaSharp-free builds, ensuring these components are available even when reflection-based discovery is not possible. Additionally, the app's build process has been standardized with new Directory.Build.props and targets files that set a specific remote control port, enable XAML source generation for CI checks, and reference the Uno.Fonts.OpenSans package.

src/SamplesApp · high confidence

The new SKCanvasElement allows SkiaSharp drawing to be rendered directly into the window's frame (zero-copy) when the active backend supports it, significantly improving performance. If the backend does not expose a native Skia canvas, the element automatically falls back to a self-contained OpenGL island (SkiaGLCanvasElement) or, as a last resort, a software raster surface, ensuring drawing remains visible across all platforms without requiring manual configuration.

src/AddIns/Uno.WinUI.Graphics2DSK · high confidence

The Uno.WinAppSDKSyncGenerator has been refactored to improve how it processes WinUI symbols and generates documentation. A new attribute generation system (AttributeDescriptionBase and specific handlers) now standardizes how attributes like ContentProperty and Bindable are emitted. The generator's build logic has been updated to load platform-specific project compilations (iOS, tvOS, Android, WASM, Skia) from Uno.WinRT and Uno.UI, ensuring accurate symbol matching after the native drop. Additionally, a new DocGenerator component automatically produces Markdown documentation detailing which WinUI views and members are implemented across different platforms.

src/Uno.WinAppSDKSyncGenerator · high confidence

The UI test generation pipeline has been updated to use new Roslyn source generators. SamplesListGenerator now uses an incremental approach to build the sample list and display source links, while CategoryBucketGenerator introduces stable hashing to distribute tests into configurable buckets for parallel execution. SnapShotTestGenerator has been enhanced to support the new SampleAttribute, allowing tests to be linked directly to types, and includes logic to ignore tests marked as manual or excluded from snapshots.

src/SamplesApp/SamplesApp.UITests.Generator · high confidence

The Tizen Skia runtime now uses a new \TizenCorePointerInputSource\ that relies on \Microsoft.UI.Input\ for pointer events. This change unifies pointer support by mapping Tizen gesture layer events (tap, move) to standard Windows pointer events, ensuring consistent input behavior across platforms.

src/Uno.UI.Runtime.Skia.Tizen · high confidence

The Uno.UI.Toolkit library has been renamed to Uno.UI.Extras, moving its types into the Uno.UI.Extras namespace and updating the XAML xmlns prefix to 'extras'. This release introduces a new accessibility API (Uno.UI.Xaml.Automation.AutomationPropertiesExtensions) allowing developers to override platform accessibility roles via a Role attached property, and adds a DiagnosticsOverlay control for injecting live analytics and diagnostic indicators into the UI. Additionally, a new DevTools.Input namespace provides internal helpers for injecting pointer, mouse, and pen input events, while CommandBarExtensions now support attached properties for subtitles, navigation commands, and back-button customization.

src/Uno.UI.Extras · high confidence

The WebAssembly runtime foundation has been reorganized to improve interop performance and reliability. The \TSInteropMarshaller\ now uses unmarshalled pointer-based invocation (\InvokeJSUnmarshalled\) instead of serializing data, which reduces overhead for JavaScript calls. New helper types like \AutoPtr\, \StructPtr\, and \HandleRef\<T\>\ manage shared memory between C\# and JavaScript more efficiently. The \InvokeJS\ mechanism has been updated to use \JSImport\ attributes for .NET 9+ and newer internal calls, while legacy internal calls are retained for older targets. Additionally, the \PlatformHelper\ now explicitly checks for 'WEBASSEMBLY' and 'BROWSER' OS platforms to ensure correct initialization, and the assembly metadata now marks the library as trimmable.

src/Uno.Foundation.Runtime.WebAssembly · high confidence

The WebGPU device bring-up and native bindings have been extracted into the new \Uno.UI.Composition.WebGpu.Init\ library. This change introduces a neutral, host-facing API (\WebGpuContext\) that creates platform-specific swapchain contexts (Win32, X11, Metal, Android, and WASM) without naming a renderer type, allowing the drawing backend to adopt the device independently. The library handles native ABI supplements for Emscripten and wgpu-native, provisions the \emdawnwebgpu\ port for WebAssembly via MSBuild targets, and manages the WASM interop seam to import JS-created GPU devices and textures into the native handle table.

src/Uno.UI.Composition.WebGpu.Init · high confidence

The XAML source generator now rejects the use of \clr-namespace:\ in xmlns declarations, enforcing stricter namespace resolution rules. This change ensures that XAML files using this specific prefix format will fail to compile, aligning the generator's behavior with updated platform standards and preventing ambiguous namespace resolution.

src/SourceGenerators · high confidence

Resolves issues where the Slider thumb was not positioned correctly after reloading or when tapping directly on the track line, and ensures the control's value remains valid in these scenarios.

src/Uno.UI · high confidence

Add UI test for BitmapIcon color change behavior; Add UI test for CommandBar long title handling with rotation; Add UI test for ResourceLoader with x:Uid parsing and prefixes; Add UI tests for CheckBox three-state behavior; Add UI tests for FlipView navigation on WASM and mobile; Add UI tests for NumberBox control behavior; Add UI tests for TwoPaneView control behavior; Add automated UI test for XAML CommandBar; Add benchmarks for XamlControlsResources performance; Add browser-specific UI tests for basic XAML transforms; Add test fixtures for external library style and resource resolution; Added Color performance benchmarks; Added Grid layout performance benchmarks; Added UI and runtime tests for ItemsControl; Added UI test for CalendarView theme toggling; Added UI test for Control IsEnabled inheritance behavior; Added UI test for Expander content occlusion; Added UI test for MessageDialog light-dismiss behavior on Android; Added UI test for RefreshContainer horizontal scroll behavior; Added UI test for hardware back button handling; Added UI tests for App.xaml resources, keyboard events, and TransformToVisual; Added UI tests for AutoSuggestBox behavior; Added UI tests for AutomationProperties.AutomationId; Added UI tests for Border control corner radius and thickness behavior; Added UI tests for Canvas measurement and ZIndex on Browser; Added UI tests for ColorAnimation, DoubleAnimation final states, and TransformGroup behaviors; Added UI tests for ContentControl behavior; Added UI tests for ContentDialog; Added UI tests for ElevatedView, Elevation, and VisibleBoundsPadding; Added UI tests for Flyout placement, dismissal, and input pass-through behavior; Added UI tests for FocusManager directional navigation; Added UI tests for FocusManager element focus tracking; Added UI tests for FrameworkElement lifecycle and layout behavior; Added UI tests for Gyrometer sensor functionality; Added UI tests for ImageBrush stretch and alignment behavior; Added UI tests for InfoBar control behavior; Added UI tests for LinearGradientBrush stop changes and opacity rendering; Added UI tests for ListView selection and pointer events; Added UI tests for MenuFlyout and MenuBar interactions; Added UI tests for NavigationView Fluent style; Added UI tests for NavigationView control behavior; Added UI tests for Page background rendering and updates; Added UI tests for PasswordBox obscuring and iOS focus behavior; Added UI tests for PipsPager control; Added UI tests for Pivot control with non-PivotItem content; Added UI tests for Popup placement, light-dismiss, and overlay behavior; Added UI tests for ProgressRing IsEnabled and Visibility behavior; Added UI tests for RadioButton enable/disable behavior; Added UI tests for RadioButtons selection and initial load behavior; Added UI tests for RadioMenuFlyoutItem selection and sub-menu behavior; Added UI tests for RenderTargetBitmap; Added UI tests for RevealBrush FallbackColor behavior; Added UI tests for ScrollBar controls; Added UI tests for Slider header display and vertical tap interaction; Added UI tests for SolidColorBrush color changes on BorderBrush and Stroke; Added UI tests for SplitView pane behavior and clipping; Added UI tests for SwipeControl behavior; Added UI tests for TextBlock control behavior; Added UI tests for TextBox control behavior; Added UI tests for Thumb control scroll prevention and drag events; Added UI tests for TimePicker flyout behavior and data context; Added UI tests for ToggleSwitch template reuse and header visibility; Added UI tests for ToolTip behavior; Added UI tests for TreeView control behavior; Added UI tests for VisualStateManager complex setters and storyboard events; Added UI tests for WebView navigation scenarios; Added UI tests for determinate ProgressRing behavior; Added UI tests for element clipping and corner radius behavior; Added UI tests for frame page stacking and pointer pass-through; Added UI tests for geometry samples on WebAssembly; Added UI tests for x:Bind validation and function binding; Added WinUI control creation and load/unload performance benchmarks; Added accessibility specification and test planning documentation; Added automated UI tests for Button control behaviors; Added automated UI tests for ListView and TreeView drag-and-drop behaviors; Added automated UI tests for ScrollViewer behavior; Added benchmark comparison for HashtableEx, Hashtable, and Dictionary; Added color code parser utility for UI tests; Added end-to-end tests for MCP integration in DevServer CLI; Added telemetry test processor for dependency injection validation; Added test specifications and API contracts for advanced WASM accessibility features; Added test suite for Uno analyzers; Added tests for DevServer add-in assembly version alignment; Added tests for DevServer app-launch tracking and add-in isolation; Added tests for Uno Hot Reload manager, workspace gating, and Roslyn integration; Breaking-changes rollout plan and tracking infrastructure; Expanded UI test coverage for Image control behaviors; Expanded UI test coverage for pointer, gesture, and focus input behaviors; Expanded test coverage for DevServer CLI internals and MCP proxy behavior; Expanded unit test infrastructure and coverage for animations and resources; Initial UI tests for TabView control; Introduce automated UI test infrastructure for the Samples App; New UI test helper extensions for scaling, coordinates, and assertions; Runtime test suite stabilization and WinUI parity alignment; SamplesApp restructured into shared project with comprehensive runtime test assertions; Updated and added UI tests for DatePicker control; Updated and expanded UI tests for ComboBox behavior and placement.

The Microsoft.CodeAnalysis package reference has been updated to version 4.14.0. This upgrade ensures compatibility with the latest Roslyn compiler features and fixes, which may impact source generation and code analysis behavior within the Uno platform tooling.

(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 42.

• Code Health 33
• Architecture 86
• Maturity 82
• Readiness 57
• Security 60
• Accessibility 32
• Performance 68

• 300 commits — 169 feature/other, 131 fixes

• src/Uno.UI — 137 commits
• src/Uno.UI.RuntimeTests — 59 commits
• (repo) — 15 commits
• src/SamplesApp — 15 commits
• src/Uno.UI.Composition — 12 commits
• src/Uno.UI.Composition.WebGpu — 12 commits
• specs/richtextblock-winui-port — 9 commits
• src/SourceGenerators — 6 commits
• src/Uno.UI.Runtime.Skia.WebAssembly.Browser — 6 commits
• src/Uno.UI.Composition.Skia — 5 commits
• doc/dev — 4 commits
• src/Uno.UI.Composition.Managed — 4 commits
• src/Uno.UI.Runtime.Skia.MacOS — 3 commits
• src/Uno.UI.Composition.Drawing — 2 commits
• src/Uno.UI.Runtime.Skia.Android — 2 commits
• src/Uno.UI.Runtime.Skia.X11 — 2 commits
• src/Uno.UI.UnitTests — 2 commits
• build/PackageDiffIgnore.xml — 1 commit
• build/test-scripts — 1 commit
• doc/articles — 1 commit

• fix: Merge pull request #24527 from ajpinedam/dev/anpi/fix.wasm.ios.keyboard.pan
• fix: Merge pull request #24553 from unoplatform/fix/richtextblock-shift-click-injection
• fix: Merge pull request #24614 from unoplatform/fix/winui-merged-app-resources-crash
• fix: Revert "fix(documents): Enforce the text schema on inline adds"
• fix: fix(a11y): Activate a focused Hyperlink from the keyboard
• fix: fix(a11y): Keep a text element's automation peer
• fix: fix(a11y): Reach embedded controls in the master from automation
• fix: fix(a11y): Report a Hyperlink's bounding rectangle
• fix: fix(a11y): Report a Hyperlink's clickable point
• fix: fix(a11y): Route keys from a focused Hyperlink
• fix: fix(composition): record through the target that owns the visual
• fix: fix(composition): stop dropping perspective from bounds and damage
• fix: fix(composition): stop mapping clips with a matrix that drops perspective
• fix: fix(documents): Correct line alignment and MaxHeight stacking
• fix: fix(documents): Count a standalone LineBreak as one flat character
• fix: fix(documents): Enforce the text schema on inline adds
• fix: fix(documents): Give an empty paragraph a non-zero formatted length
• fix: fix(documents): Guard the unported text drawing context
• fix: fix(documents): Handle empty inline collections in the run model
• fix: fix(documents): Honor WinUI Typography defaults in the inherited snapshot
• …and 280 more

• 4 HTTP endpoints (baseline)

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

unoplatform/uno 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.