Skip to content
CAI
Software that uses CAICheck a score

unoplatform/uno

35.3

Weak · 13 November 2026

1235.9k

lines of production code

C#

primary language

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add BenchmarkDotNet sample page and control

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

Add DataTemplate Update Sample demonstrating runtime template modification

A new sample page has been added to the SamplesApp that demonstrates how to update a shared DataTemplate at runtime using the TemplateManager. The sample allows users to click buttons to change the template's content (e.g., from a TextBlock to a colored Rectangle) and observe the changes reflected across multiple presenters like ContentPresenter, ContentControl, ItemsControl, ListView, and ItemsRepeater. This functionality is explicitly disabled on WinAppSDK, where a message indicates the feature is unavailable.

src/SamplesApp/SamplesApp.Samples/Uno/Templates · high confidence

Add Git Branching Workflow extension to Spec Kit

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

Add Help page with keyboard shortcuts and navigation guide

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

Add NUnit test result analysis tool

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

Add Playground sample for live XAML preview

The Playground sample in the SamplesApp now provides a live XAML preview environment. Users can edit XAML code in a text editor and click 'Apply' to render the result in real-time, with support for common namespaces like Uno.Toolkit.UI and Microsoft UI XAML controls. The last used XAML is persisted in local settings for convenience.

src/SamplesApp/SamplesApp.Samples/Playground · high confidence

Add RichEditBox UIA validation tool

A new out-of-process tool (RichEditBoxUiaClient) has been added to src/Tools to validate the UI Automation exposure of the RichEditBox control. This utility connects to a running SamplesApp instance to verify that external accessibility clients (such as screen readers) correctly see Text, Text2, and TextEdit patterns, text attributes, hyperlink/image children, and structure/property change events. It serves as a parity baseline against native WinUI by supporting a 'native' comparison mode, ensuring the managed implementation behaves consistently with the underlying Windows UI Automation COM boundary.

src/Tools · high confidence

Add TitleBar sample UI for manual testing

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

Add UI test behaviors for ListView, SplitView, and WebView controls

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

Add UI test converter utilities for the Samples App

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

Add Uno.ResourceTrimmingValidator tool

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

Add Wasm viewport orientation telemetry sample

A new diagnostic sample page for the Wasm target allows users to monitor and compare the Uno Platform window size against the browser's document element size during device rotation. The sample polls both values every 100ms, displays raw browser event counts, and visually indicates if the app's measured size lags behind the settled viewport (displaying a 'STALE' status), helping to identify rendering issues where mobile browsers fire resize events before layout reflow.

src/SamplesApp/SamplesApp.Samples/Wasm · high confidence

Add WinUI-based Dependency Property benchmarks

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

Add correlation ID support to IDE channel messages

A new record type, IdeMessageWithCorrelationId, has been introduced in the Uno.UI.RemoteControl.Messaging.IdeChannel namespace. This type extends the existing IdeMessage base class to include a CorrelationId property, enabling messages sent through the IDE channel to be tracked and correlated across different operations.

Uno.UI.RemoteControl.Messaging · high confidence

Add default styling for SampleControl in UI tests

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

Add global assembly metadata for Uno

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

Add helper utilities for the SamplesApp

The SamplesApp now includes a set of helper classes and interfaces in the Helpers directory to support sample implementations and UI testing. This includes BindableBase and ViewModelBase for property change notification and command handling, UWPViewHelper for pixel conversion logic, RectCloseComparer for geometric comparisons, SkiaSamplesAppHelper for file saving on Skia-WASM, and WaitableSampleImageHelpers for synchronizing image loading in tests.

src/SamplesApp/SamplesApp.Samples/Helpers · high confidence

Add in-app review support for Android via Google Play Core

The Uno.UI.GooglePlay add-in now supports requesting in-app reviews on Android. A new StoreContextExtension class implements the IStoreContextExtension interface, leveraging the Xamarin.Google.Android.Play.Core.Review library to request and launch the review flow. The implementation handles context resolution, ensuring the review dialog is hosted in the correct window context when available, and falls back to the current activity if not. It also includes error handling for cases where no activity is available to host the review flow.

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

Add runtime unit tests runner and HTTP handler sample to Samples App

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

Add sample web content for local file loading and trackpad event testing

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

Add shared benchmark project for UI controls and resources

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

Add static resource and value converter samples to the Samples App

The Samples App now includes new demonstration files for using static resources and value converters. A new StaticResource\_Simple sample shows how to define resources in XAML and C\# and bind them to UI elements, including a local converter. Additionally, new value converter implementations have been added to demonstrate boolean negation, nullable boolean-to-value mapping, and string conversion for display purposes.

src/SamplesApp/SamplesApp.Samples/Resources, src/SamplesApp/SamplesApp.Samples/ValueConverters · high confidence

Add tvOS platform support to SamplesApp

The SamplesApp now includes the necessary configuration files and entry point to run on tvOS. This adds an Info.plist defining app metadata and permissions (camera, microphone, etc.), a linker configuration to preserve Uno.UI assemblies, a Main.tvOS.cs entry point that initializes the Uno platform host and configures the drawing backend, and launch image assets. These changes enable the sample application to build and launch on Apple TV devices.

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

Added FontFallbackPreprocessor tool to generate font fallback maps

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

Added ResourcesExtractor tool for generating localized WinUI resources

A new standalone WinUI application named ResourcesExtractor has been added to the src directory. This tool automates the generation of localized .resw resource files by reading resource definitions from WinUI source headers (such as localizedResource.h) and extracting localized strings from the Microsoft.UI.Xaml.dll binary for various languages. The application is configured to publish as a self-contained, full-trust desktop app for x86, x64, and ARM64 targets.

src/ResourcesExtractor · high confidence

Added WinUI-based benchmarks for Border and FrameworkElement

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

Added inline TOC generator for documentation

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

Added keyboard-aware scrolling for input fields

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

Added sample assets for sculptures-in-words and variable font collection

The SamplesApp now includes new asset files to support two additional demonstration samples: a 'sculptures-in-words' sample, which adds 3D model data (\.bin\, \.mesh\) and texture assets, and a 'variable font collection' sample, which adds a TrueType Collection font file and its associated license. These resources are now available for users to explore within the application's sample gallery.

src/SamplesApp/SamplesApp.Samples/Assets · high confidence · unverified

Android foldable and dual-screen support added to Uno.UI.Foldable

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

Android native motion event handling and view group infrastructure

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

Android runtime restructured with Skia accessibility bridge and new host builder

The Android runtime has been restructured to introduce a new Skia-based accessibility bridge (AndroidSkiaAccessibility and UnoExploreByTouchHelper) that projects the WinUI automation-peer tree into native Android accessibility nodes, and to add a new AndroidHostBuilder with UseVulkan/UseOpenGL configuration. The ApplicationActivity now supports predictive back gestures on Android 16+ via OnBackPressedCallback, and input handling is centralized through per-window AndroidCorePointerInputSource and AndroidKeyboardInputSource wired via the new AndroidSkiaXamlRootHost. A JNI helper (AccessibilityNodeInfoCompatJni) ensures setChecked compatibility across AndroidX.Core 1.16 and 1.17, and permissions are initialized via PermissionsHelper.

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

DevServer CLI introduces manifest-based add-in discovery and workspace resolution helpers

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

DevServer extensibility and reliability improvements

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

DevServer now tracks application launch and connection lifecycle with structured telemetry

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

Enhanced Visual Studio integration with deterministic app launch tracking and dynamic menu support

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

Hot Reload server gains batched IDE updates, Roslyn metadata updates, and workspace recovery

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

Introduce ChangeSet model for batched hot-reload change tracking

The Uno.HotReload module now uses a new \ChangeSet\ record to describe the set of changes detected in a batch of modified files, including edits, additions, removals, and ignored files. This model aggregates document and project changes, providing properties to check for add/remove operations or project edits, and a method to enumerate all file paths touched by the change set for downstream reporting.

Uno.HotReload · high confidence

Introduce Microsoft.Extensions.Logging adapter

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

Introduce Uno.HotReload package with new diffing and update pipeline

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

Introduce Uno.Sdk as the new unified build system

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

Introduce Uno.UI.MSAL add-in for platform-specific MSAL integration

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

Introduce Uno.UI.TestComparer for automated UI screenshot regression testing

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

Introduce Uno.UI.XamlHost for hosting UWP XAML in Uno Islands

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

Introduce WebGPU composition backend with generated native bindings and managed tessellation

This change adds the initial scaffolding for the \Uno.UI.Composition.WebGpu\ backend, enabling hardware-accelerated composition via the WebGPU standard. It includes a Python script (\gen\_webgpu.py\) to generate C\# interop bindings from the \wgpu-native\ modern \webgpu.h\ ABI (version v29.0.1.1), a \PathTessellator\ for analytic anti-aliased fills, and core recording infrastructure (\WebGpuCommandRecorder\, \WebGpuCommands\) that supports drawing primitives, layers, and clips without requiring SkiaSharp.

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

Introduce WinUI 3 OpenGL 3D graphics support on Windows

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

Introduce headless and X11 runtime hosts

Added new runtime host implementations for headless (offscreen) and X11 (Linux) environments. The headless host enables running Uno applications without a display server, supporting per-window configuration of rasterization scale and size, and maintaining the render cycle for features like RenderTargetBitmap. The X11 host provides native windowing, input handling (keyboard, pointer, IME via D-Bus), clipboard/drag-and-drop, and configurable rendering backends (Vulkan, OpenGL, OpenGLES, Software) for Linux desktop deployment. Also in this area: Android, Headless, and WebAssembly renderers now expose the drawing backend via the IXamlRootHost interface.

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

Introduce in-process devserver hosting and hot-reload workspace limits

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

Introduce new runtime test runner and UI control in SamplesApp

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

Introduces Claude code-review agent panel for Uno Platform contributions

Adds a set of specialized Markdown-based agent definitions (architect, contract, jerome, operability, performance, quality, security) under .claude/agents/ to automate pre-commit code reviews. These agents enforce Uno Platform-specific conventions—such as Skia-only UI layering, WinUI API parity, source-generator cancellation discipline, and logging standards—by reviewing diffs for architectural fit, public contract stability, performance hazards, and security boundaries. Contributors can now invoke these agents to catch layering violations, breaking API changes, and hot-path allocations before merging, improving code quality and consistency across the framework.

.claude · high confidence

Introduces native Apple UIKit runtime for iOS and tvOS

Adds a new runtime implementation for Apple platforms, replacing the previous Skia-based host with a native UIKit architecture. This change introduces a full accessibility bridge that exposes XAML automation peers to VoiceOver and Switch Control, implements native pointer and keyboard input handling for touch and Siri Remote navigation, and standardizes activation routing (URLs, universal links, and jump lists) through the AppInstance API to ensure consistent behavior across scene and app lifecycle events.

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

Introduction of Uno.Foundation.Logging with weak-keyed caching and thread-safe factory

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

Neutral drawing and effects API with comprehensive font fallback

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

New CI test harnesses for Android, iOS, Linux, and macOS Skia runtime tests

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

New ElevatedView and VisibleBoundsPadding samples in the Toolkit

The SamplesApp now includes a comprehensive set of interactive samples for the ElevatedView control and VisibleBoundsPadding behavior. The ElevatedView samples demonstrate how to configure elevation levels, shadow colors, border thickness, and corner radii, including specific tests for clipping and layout interactions. Additionally, new samples illustrate how VisibleBoundsPadding behaves within modal presentations, specifically addressing how Uno elements are handled on iOS and tvOS when presented over the visible bounds.

src/SamplesApp/SamplesApp.Samples/Toolkit · high confidence

New GLCanvasElement for hardware-accelerated 3D graphics

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

New Generated Animations Playground for Lottie samples

A new interactive playground page has been added to the SamplesApp, allowing users to load and test Lottie animations generated by LottieGen (WinUIVersion 3.0) via the AnimatedVisualPlayer. The page provides controls to switch between five sample animations (Watermelon, Gradient shapes, Lottie logo, Pin jump, Hamburger arrow), adjust playback rate, set progress ranges, and toggle auto-play, loop, pause, resume, and stop states. The generated C\# animation sources are included and rendered using the Skia backend.

src/SamplesApp/SamplesApp.Samples/AnimatedVisualPlayerPlayground · high confidence

New GitPod environment configuration for .NET 8+ and .NET 11 Preview 5

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

New Raspberry Pi guide and .NET installation script

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

New Reference Implementation Comparer tool for validating Uno.UI packages

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

New Skia-free managed drawing, font, and image decoding engines

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

New Uno Islands sample application with WinUI 3 and XAML Islands

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

New Uno.Foundation and Uno.WinRT NuGet packages for .NET 10 and 11

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

New Uno.WinUI Spell Checking add-in with Hunspell integration

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

New WinRT APIs for Appointments, Background Tasks, and Call History

The Uno.WinRT library now includes implementations for several Windows Runtime namespaces, enabling apps to interact with system services. The \Windows.ApplicationModel.Appointments\ namespace provides APIs to query and display calendar appointments, including Android-specific logic for reading the device calendar. The \Windows.ApplicationModel.Background\ namespace adds support for registering and managing background tasks using system triggers (such as network state changes or time intervals) and conditions. Additionally, the \Windows.ApplicationModel.Calls\ namespace introduces APIs to access the phone call history, allowing apps to read past call logs and monitor call state changes on Android and iOS. Also in this area: Fix Android Alt key modifier mapping; Add AppInstance and AppActivationArguments APIs for unified activation handling; Fix crash when loading Jump List with non-Uno shortcuts on Android; Fix nullability and single-assignment safety in accessibility helpers; Sync WinAppSDK generated metadata for AppLifecycle and Clipboard; and 2 more.

src/Uno.WinRT · high confidence

New Windows ApplicationModel samples for system integrations

The SamplesApp now includes new interactive samples for Windows-specific ApplicationModel APIs, allowing users to test system integrations directly. These additions cover appointment management (AppointmentStore), call history and phone call management, SMS composition via ChatMessageManager, clipboard operations (copy/paste text, HTML, images, and files), contact picking, data transfer and sharing (DataTransferManager), email composition, and package information retrieval.

src/SamplesApp/SamplesApp.Samples/Windows · high confidence

New XAML Trimming Validator Tool

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

New XAML samples for AdaptiveTrigger, Application lifecycle, and Accessibility automation

The SamplesApp now includes new demonstration pages for several XAML features. The AdaptiveTrigger sample allows toggling a window-size override to test layout changes against a resizable item rather than the actual window bounds. The Application samples demonstrate the DispatcherShutdownMode property (switching between OnLastWindowClose and OnExplicitShutdown) and provide buttons to trigger app exit via Application.Current.Exit() or CoreApplication.Exit(). Additionally, a comprehensive set of Automation samples has been added to showcase accessibility properties, including screen reader support (names, roles, landmarks, live regions, offscreen status), mobile automation fixtures (invoke, toggle, range, text, relations), and dynamic structure changes.

src/SamplesApp/SamplesApp.Samples/Microsoft/UI/Xaml · high confidence

New accessibility subsystem for WebAssembly browser runtime

Adds a comprehensive accessibility implementation for the WebAssembly browser host, introducing a semantic DOM tree that mirrors the XAML visual tree for screen reader consumption. This includes a \FocusSynchronizer\ to bridge XAML focus with the browser's active element, a \LiveRegionManager\ with debouncing and throttling for announcements, and \ModalFocusScope\ to trap focus within dialogs. The system also features a \SemanticElementFactory\ to map XAML controls to ARIA roles, \VirtualizedSemanticRegion\ support for virtualized lists, and specialized handling for ComboBox dropdowns to ensure valid ARIA structures. A debug overlay tool is provided to visualize the semantic tree during development.

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

New and improved static analyzers for Uno platform correctness

The Uno.Analyzers package now includes three new diagnostic analyzers and significant improvements to the existing UnoNotImplementedAnalyzer. The new UnoDoNotDisposeNativeViews analyzer (UNO0002) warns against calling Dispose on native views like UIKit.UIView, which can cause runtime crashes. The UnoInitializeComponentAnalyzer (UNO0006) ensures that XAML code-behind types inheriting from Application or DependencyObject correctly call InitializeComponent in their constructors. Additionally, the UnoNotImplementedAnalyzer (UNO0001) has been rewritten to use IOperation, allowing it to detect unimplemented members in more contexts (such as method references and typeof expressions) and correctly map not-implemented tokens to specific Uno platform flavors (Android, iOS, WebAssembly, etc.) to reduce false negatives.

src/Uno.Analyzers · high confidence

New build infrastructure and tooling scripts

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

New diagnostic utilities for visual state and layout measurement testing

Added two new utility controls to the SamplesApp to aid in debugging and verifying UI behavior. The ControlStateViewer allows developers to inspect all visual states of a specific control type by instantiating it and applying different states, while the RainbowMeasures panel provides a visual indicator (changing background color) during layout measurement passes, helping to verify that MeasureOverride and ArrangeOverride are being called as expected.

src/SamplesApp/SamplesApp.Samples/Utilities · high confidence

New documentation build infrastructure and tooling

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

New helper utilities for the SamplesApp shell and UI testing

The SamplesApp now includes a suite of helper classes in the UITests/Views/Helper directory to support the new shell navigation and styling. These include ShellFunctions for x:Bind data transformations (such as visibility toggles, search result flattening, and breadcrumb logic), ShellThemeBrushes for resolving theme-aware colors in code-behind, and ShellMonospace for cross-platform font handling. Additional helpers like ContentNavigationBehavior, DelegateCommand, and ShellSelectionIndicator provide navigation state tracking, command patterns, and selection indicators specifically for the Uno platform, while SampleHelper and ShellConfirmFlyout offer lifecycle utilities and confirmation dialogs for the sample browser.

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

New input validation sample demonstrating INotifyDataErrorInfo integration

A new sample page has been added to the SamplesApp that demonstrates how to surface validation errors from a ViewModel implementing INotifyDataErrorInfo. The sample shows how to bind the Validation.Errors attached property to an ItemsControl to display error messages for TextBox, PasswordBox, and ComboBox controls, illustrating the Uno Platform-specific input validation feature.

src/SamplesApp/SamplesApp.Samples/Uno/UI · high confidence

New isolated Codespaces dev container with DNS allowlist and Claude Code integration

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

New messaging infrastructure for dev-server and IDE communication

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

New repository configuration and contributor guidance files

The repository now includes foundational configuration and documentation files to standardize development workflows and onboarding. A comprehensive \.editorconfig\ enforces consistent code formatting and C\# style rules across all source files. CI/CD behavior is defined by \.vsts-ci.yml\ and \.vsts-ci-docs.yml\, which configure Azure DevOps pipelines for code and documentation builds respectively, including specific .NET SDK versions and target frameworks. Developer experience is enhanced with \.gitpod.yml\ for cloud-based development, \.mergify.yml\ for automated pull request merging, and \.codacy.yml\ to exclude generated or non-product code from analysis. Additionally, \AGENTS.md\ and \CLAUDE.md\ provide structured guidance for AI coding assistants, while \CONTRIBUTING.md\ and \CODE\_OF\_CONDUCT.md\ establish community standards and contribution processes.

(repo-wide) · high confidence

New sample browsing and testing infrastructure in SamplesApp

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

New uno53AppWithLib solution template for Uno Platform 5.3

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

Redesigned documentation UI with fixed feedback box and improved navigation

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

Register StoreContext extension for Android via Uno.WinRT

The Google Play add-in now registers a StoreContext extension for Android through the Uno.WinRT integration. This change enables Android applications to access store context functionality via the Uno platform's extensibility model, allowing for consistent store-related APIs across platforms.

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

Restored CookieManager sample for WebAssembly

The CookieManager sample page has been restored in the SamplesApp, providing a UI to manage HTTP cookies on WebAssembly targets. Users can now set, retrieve, and delete cookies by configuring properties such as name, value, path, domain, expiration, secure flag, and SameSite policy, with results displayed in the interface.

src/SamplesApp/SamplesApp.Samples/Uno/Web · high confidence

SamplesApp localized string resources added for multiple languages

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

Skia-based SVG renderer added as opt-in add-in with performance caching

The Uno.UI.Svg add-in now provides a Skia-backed SVG renderer (SkiaSvgRenderer) that serves as the default when referenced, replacing the previous managed engine. This renderer draws SVGs as vectors directly into the Skia canvas for crisp scaling, while caching a rasterized texture for cross-backend fallbacks (e.g., WebGPU) to avoid per-frame allocation. The add-in is registered via extension methods in SkiaBackendSvgExtensions, allowing explicit registration for trimmed/AOT scenarios.

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

Uno documentation template introduces SDK version badge and update modal

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

Upgrade documentation templates with Algolia DocSearch, Mermaid diagrams, and Google Tag Manager

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

Architecture

Introduction of Uno.Foundation as a dedicated Windows.Foundation API implementation

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

Skia backend moved to a dedicated assembly with SkiaSharp-free architecture

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

Behavioural changes

10 commits (1 fix) modifying src/SamplesApp/SamplesApp.Samples/Microsoft/UI/Composition

A change to existing behaviour in src/SamplesApp/SamplesApp.Samples/Microsoft/UI/Composition — 10 commits (1 fix), 152 files: “feat(samples): Add scrollable morphing shapes sample”; “feat: Add WebGpuCanvasElement”; “fix(samples): Catch errors in the context leak sample run”; and 7 more.

src/SamplesApp/SamplesApp.Samples/Microsoft/UI/Composition · medium confidence · unverified

2 commits (1 fix) modifying src/SamplesApp/SamplesApp.Samples/Windows\_UI\_Xaml

A change to existing behaviour in src/SamplesApp/SamplesApp.Samples/Windows\_UI\_Xaml — 2 commits (1 fix), 1 file: “fix(textbox): Keep hardware typing when the keyboard is suppressed”; “chore(samples): Skip IdleFrameProbe in snapshots”.

_src/SamplesApp/SamplesApp.Samples/Windows\_UI\Xaml · medium confidence · unverified

4 commits (1 fix) modifying build/test-scripts/Win32UiaEventProbe

A change to existing behaviour in build/test-scripts/Win32UiaEventProbe — 4 commits (1 fix), 2 files: “ci: Run the UIA structure event probe on Windows”; “fix(win32): Correct UIA structure event ABI”; “test(win32): Tidy the UIA structure event probe”; and 1 more.

build/test-scripts/Win32UiaEventProbe · medium confidence · unverified

4 commits (2 fixes) modifying src/AddIns/Uno.UI.MediaPlayer.X11

A change to existing behaviour in src/AddIns/Uno.UI.MediaPlayer.X11 — 4 commits (2 fixs), 3 files: “fix(mediaplayer): Order queued commands with disposal”; “fix(mediaplayer): Keep Win32 Stop before later Play”; “refactor!: Drop Skia from the host projects, assemblies and namespaces”; and 1 more.

src/AddIns/Uno.UI.MediaPlayer.X11 · medium confidence · unverified

4 commits (2 fixes) modifying src/SamplesApp/SamplesApp

A change to existing behaviour in src/SamplesApp/SamplesApp — 4 commits (2 fixs), 3 files: “chore(samplesapp): drop the RenderDoc capture hook”; “fix(textbox): Keep hardware typing when the keyboard is suppressed”; “fix(samplesapp): Restore the app identity manifest embed”; and 1 more.

src/SamplesApp/SamplesApp · medium confidence · unverified

40 commits (5 fixes) modifying src/Uno.Foundation.Runtime.WebAssembly

A change to existing behaviour in src/Uno.Foundation.Runtime.WebAssembly — 40 commits (5 fixs), 11 files: “chore: Cleanup unneeded IsNetCore on Wasm”; “chore: Adjust for threading”; “refactor(wasm)!: Remove interop whose JavaScript is no longer shipped”; and 37 more (refs \#56309).

src/Uno.Foundation.Runtime.WebAssembly · medium confidence · unverified

5 commits (1 fix) modifying src/SamplesApp/SamplesApp.Samples/Msal

A change to existing behaviour in src/SamplesApp/SamplesApp.Samples/Msal — 5 commits (1 fix), 2 files: “test(samples): Cancel and time out MSAL sign-in”; “chore: resolve master merge conflicts”; “chore(samplesapp): Drop Microsoft.Graph from the wasm head”; and 2 more.

src/SamplesApp/SamplesApp.Samples/Msal · medium confidence · unverified

50 commits (23 fixes) modifying src/Uno.UI.Composition.WebGpu.Init

A change to existing behaviour in src/Uno.UI.Composition.WebGpu.Init — 50 commits (23 fixs), 18 files: “feat(webgpu): JS-primary offscreen render target on the browser seam”; “refactor(drawing): typed present + neutral render-target family”; “fix(webgpu): Retry a macOS frame presented while hidden”; and 47 more.

src/Uno.UI.Composition.WebGpu.Init · medium confidence · unverified

6 commits (1 fix) modifying src/SamplesApp/SamplesApp.Samples/Microsoft/UI/Windowing

A change to existing behaviour in src/SamplesApp/SamplesApp.Samples/Microsoft/UI/Windowing — 6 commits (1 fix), 33 files: “fix(macos): Close windows on Exit, as WinUI”; “refactor(samples): Nest sample folders by namespace”; “test(macos): Add manual sample for app quit”; and 3 more.

src/SamplesApp/SamplesApp.Samples/Microsoft/UI/Windowing · medium confidence · unverified

66 commits (8 fixes) modifying build/filters

A change to existing behaviour in build/filters — 66 commits (8 fixs), 7 files: “build: Avoid building some unit test projects in reference build”; “refactor(build): Name the generic WinRT-layer projects \*.Generic.csproj”; “chore: don't build Graphics3DGL binaries on UWP”; and 63 more (refs \#2104).

build/filters · medium confidence · unverified

Android platform initialization and configuration updated

The Android host for the SamplesApp has been reconfigured to use the UnoPlatformHostBuilder, replacing the previous Skia-based host. This change includes the addition of a new AndroidManifest.xml file targeting SDK 36, the migration of permission declarations to AssemblyInfo.cs, and the removal of the Skia base library dependency from the Android project structure.

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

CI pipeline enhancements: master build checks, conditional test scoping, and package validation

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

Composition rendering moves to a neutral drawing seam with SkiaSharp 4 support

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

DocSearch results now disambiguate identical titles with page context

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

Documentation updates for Uno Platform 7.0 and .NET 10 support

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

Enhanced UI test reliability and screenshot validation

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

Fluent Theme V2 resources and build pipeline introduced

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

Hot Reload client now supports pausing UI updates and self-reconnecting to the DevServer

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

Improved Algolia DocSearch index quality and deduplication

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

Introduces NativeDispatcher for platform-specific UI thread scheduling

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

Manual equality implementation for WinRT structs

The Uno.WinRT generator now emits hand-written equality logic for WinRT structs like HolographicAdapterId, implementing IEquatable, operator overloads, and GetHashCode. This ensures consistent value comparison behavior for these types across platforms, whereas previously generated code may have relied on default or incomplete equality semantics.

Uno.WinRT · high confidence

New SampleChooserViewModel implementation for UI test presentation

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

New WebAssembly host entry point and configuration for SamplesApp

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

New master layout template for Uno documentation

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

Rename SamplesApp.Head to SamplesApp and add platform-specific configuration files

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

SamplesApp drawing backend configuration and build setup

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

SkiaSharp drawing now uses zero-copy rendering with automatic fallbacks

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

UI test generation refactored with new source generators and bucketing

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

Uno.UI.Extras rebranded from Uno.UI.Toolkit with new accessibility, diagnostics, and dev tools

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

Updated desktop host initialization with X11 and Win32 rendering backend support

The desktop entry point (Program.cs) has been updated to explicitly configure the UnoPlatformHost for both X11 and Win32 environments. This change introduces support for forcing specific rendering backends (Vulkan, OpenGL, OpenGLES, or Software) via environment variables (UNO\_X11\_RENDERER and UNO\_WIN32\_RENDERER) during development and testing. It also registers the X11NativeWebViewProvider for WebView2 support on Linux/X11 systems and ensures proper assembly loading for Skia dependencies. The host now preloads the media player for both X11 and Win32 targets and configures the drawing backend to support both Skia and WebGPU managed seams.

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

WinAppSDK Sync Generator restructured with new attribute handling and platform-specific compilation logic

The WinAppSDK Sync Generator has been significantly refactored to improve how it mirrors WinUI APIs and manages platform-specific code generation. A new attribute generation system (using classes like AttributeDescriptionBase and specific handlers for Bindable, ContentProperty, and AttributeUsage) now standardizes how metadata attributes are emitted. The generator's core logic has been updated to align with the Uno 7.0 native drop, explicitly routing platform-specific symbols (iOS, Android, tvOS) through Uno.WinRT and handling Skia-only libraries differently to avoid emitting invalid non-Skia defines. Additionally, the generator now includes a DocGenerator to automatically produce and maintain documentation on implemented views, and introduces helper classes for robust symbol matching and project loading to ensure generated stubs accurately reflect the underlying Uno and WinUI type hierarchies.

src/Uno.WinAppSDKSyncGenerator · high confidence

X11 WebView now uses WebKit2GTK instead of Skia

The X11 WebView implementation has switched its underlying rendering engine from Skia to WebKit2GTK. This change introduces a new \X11NativeWebView\ class that initializes a GTK thread, loads the WebKit2GTK libraries, and manages the native web view window. Users on Linux environments will now rely on the WebKit2GTK stack for WebView rendering on X11, which may affect performance characteristics and feature support compared to the previous Skia-based approach.

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

XAML source generator rejects clr-namespace xmlns declarations

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

Fixes

10 commits (6 fixes) fixing src/Uno.UI.Runtime.Linux.FrameBuffer

A fix in src/Uno.UI.Runtime.Linux.FrameBuffer — 10 commits (6 fixs), 38 files: “fix(framebuffer): Fail a page flip that finds no flip in flight”; “fix(framebuffer): Draw DRM frames on the page-flip thread only”; “fix(framebuffer): Pace software rendering when vsync is unavailable”; and 7 more.

src/Uno.UI.Runtime.Linux.FrameBuffer · medium confidence · unverified

31 commits (19 fixes) fixing src/Uno.UI.Runtime

A fix in src/Uno.UI.Runtime — 31 commits (19 fixs), 34 files: “perf(a11y): check for listeners without allocating”; “fix(vulkan): Try software devices last on Win32”; “perf(a11y): Check automatic peer changes once after layout”; and 28 more.

src/Uno.UI.Runtime · medium confidence · unverified

31 commits (26 fixes) fixing src/Uno.UI.Runtime.X11

A fix in src/Uno.UI.Runtime.X11 — 31 commits (26 fixs), 71 files: “fix(x11): skip tree rebuild for already-published peers”; “fix(x11): harden AT-SPI password, signals, writes”; “fix(skia-x11): Fix TIMESTAMP XChangeProperty in X11ClipboardExtension”; and 28 more.

src/Uno.UI.Runtime.X11 · medium confidence · unverified

4 commits (3 fixes) fixing src/Uno.UI.Runtime.Win32.Support

A fix in src/Uno.UI.Runtime.Win32.Support — 4 commits (3 fixs), 15 files: “fix(win32): Don't throw while describing a Win32 error”; “fix(win32): Remove the unused DpiBootstrap error helper”; “refactor!: Drop Skia from the host projects, assemblies and namespaces”; and 1 more.

src/Uno.UI.Runtime.Win32.Support · medium confidence · unverified

41 commits (27 fixes) fixing src/Uno.UI.Runtime.Win32

A fix in src/Uno.UI.Runtime.Win32 — 41 commits (27 fixs), 65 files: “fix(win32): Explain a WebView left out of the app”; “perf(win32): Create the Vulkan device in the background”; “fix(win32): Preserve live UIA cleanup lookups”; and 38 more.

src/Uno.UI.Runtime.Win32 · medium confidence · unverified

48 commits (30 fixes) fixing src/Uno.UI.Runtime.MacOS

A fix in src/Uno.UI.Runtime.MacOS — 48 commits (30 fixs), 79 files: “feat(composition): Tick per-frame motion from a frame clock”; “fix(macos-a11y): Expose RichEditBox placeholder to VoiceOver”; “fix(richeditbox): align current SDK contracts”; and 45 more.

src/Uno.UI.Runtime.MacOS · medium confidence · unverified

Fixes for Slider thumb positioning and value validity

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

Test coverage

Add UI test for BitmapIcon color change behavior; Add UI test for CommandBar long title handling with rotation; Add UI tests for FlipView navigation on WASM and mobile; 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 runtime tests for secondary AssemblyLoadContext (ALC) hosting; Add test fixtures for external library style and resource resolution; Added Android UIAutomator accessibility tests for mobile controls; Added Color performance benchmarks; Added Grid layout performance benchmarks; Added MSTest interoperability layer for UI tests; Added UI and runtime tests for ItemsControl; Added UI test for CalendarView theme toggling; 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 tests for AutoSuggestBox behavior; 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 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 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 Popup dismissal and overlay behavior; Added UI tests for ProgressRing IsEnabled and Visibility 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 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 ToolTip behavior; Added UI tests for TreeView control behavior; Added UI tests for UIElement keyboard events and TransformToVisual; Added UI tests for WebView navigation scenarios; Added UI tests for Windows UI XAML Geometry samples; Added UI tests for basic XAML shapes; 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 the SamplesApp shell and runner controls; Added UI tests for x:Bind validation and function binding; Added UITest for BindableDrawerLayout pane reset behavior; 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; Added tests for assembly comparison logic; 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 coverage for Uno.UI animations and resource resolution; 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; SamplesApp restructured into shared project with comprehensive runtime test assertions; Shell UI test styles now use theme-aware resources; Updated and added UI tests for DatePicker control; Updated and expanded UI tests for ComboBox behavior and placement.

Dependencies

Introduce new Uno Platform add-in packages and update documentation tooling

This release adds several new add-in packages to extend platform support: Uno.UI.MSAL for authentication, Uno.UI.MediaPlayer for Win32 and X11 targets, Uno.UI.Svg for SVG rendering, Uno.WinUI.Graphics2DSK for cross-runtime 2D graphics, and Uno.WinUI.SpellChecking for text validation. It also introduces Uno.UI.WebView.X11 for web content on X11 systems. Additionally, the documentation build tooling in the /doc directory has been updated with new Gulp and PostCSS dependencies.

(dependencies) · high confidence

Housekeeping

Samples app folder structure reorganized

The internal folder structure of the SamplesApp has been reorganized, specifically renaming the UITests.Shared folder to SamplesApp.Samples. This change affects the location of sample resources, including Lottie animations and message dialog tests, but does not alter the functionality or user experience of the samples themselves.

src/SamplesApp/SamplesApp.Samples/Lottie, src/SamplesApp/SamplesApp.Samples/MessageDialogTests, src/SamplesApp/SamplesApp.Samples/UITestsStrings · high confidence · unverified

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

How this codebase got here

Score

  • CAI 36 → 35 (-1.0)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.

Lenses

  • Code Health 39 → 39 (+0.1)
  • Architecture 81 → 67 (-14.0)
  • Maturity 80 → 81 (+0.6)
  • Readiness 51 → 59 (+8.2)
  • Security 48 → 46 (-1.4)
  • Accessibility 22 → 20 (-2.6)
  • Performance 68 → 71 (+3.0)

Resolved (207)

  • ADR has no Context and Consequences section (specs/055-hotdesign-previews-folder-rename/spec.md)
  • Change coupling: DiscoveryInfo.cs ↔ HealthService.cs (src/Uno.UI.DevServer.Cli/Helpers/DiscoveryInfo.cs)
  • Change coupling: Given_AccessibleListView.cs ↔ Given_AccessibleTextBox.cs (src/Uno.UI.RuntimeTests/Microsoft/UI/Xaml/Automation/Given_AccessibleListView.cs)
  • Change coupling: Given_ListViewBase.cs ↔ Given_ToolTip.cs (src/Uno.UI.RuntimeTests/Microsoft/UI/Xaml/Controls/Given_ListViewBase.cs)
  • Change coupling: Given_MenuFlyout.cs ↔ Given_ToolTip.cs (src/Uno.UI.RuntimeTests/Microsoft/UI/Xaml/Controls/Given_MenuFlyout.cs)
  • Change coupling: WebGpuInit.ts ↔ BrowserRenderer.cs (src/Uno.UI.Composition.WebGpu/ts/Runtime/WebGpuInit.ts)
  • Change-coupling hub: WebGpuBackend.cs → WebGpuBrowserGraphicsContext.cs, WebGpuJsInterop.cs, WebGpuSwapChainContext.cs, WebGpuDevice.cs, WebGpuPathAtlas.cs (src/Uno.UI.Composition.WebGpu/WebGpuBackend.cs)
  • Checkable ADR rule enforced only by prose: AnimatedVisualPlayer reconciliation — provenance & decision log (specs/056-animatedvisual-reconciliation/decisions.md)
  • CommentedOutCode (src/Uno.UI/UI/Xaml/Controls/DatePicker/DatePickerFlyoutItem_Partial.cs)
  • CommentedOutCode (src/Uno.UI/UI/Xaml/Controls/DatePicker/DatePickerFlyoutItem_Partial.cs)
  • CommentedOutCode (src/Uno.UI/UI/Xaml/Controls/Primitives/Selector.cs)
  • CommentedOutCode (src/Uno.UI/UI/Xaml/Controls/Primitives/Selector.cs)
  • Coverage not measured — no coverage collector is wired up
  • DeadPreprocessorBranch (src/Uno.Foundation.Runtime.WebAssembly/Interop/TSInteropMarshaller.wasm.cs)
  • DeadPreprocessorBranch (src/Uno.Foundation.Runtime.WebAssembly/Interop/TSInteropMarshaller.wasm.cs)
  • DeadPreprocessorBranch (src/Uno.UI/UI/Xaml/Controls/Primitives/Selector.cs)
  • DeadPreprocessorBranch (src/Uno.UI/UI/Xaml/Controls/Primitives/Selector.cs)
  • DeadPreprocessorBranch (src/Uno.WinRT/Storage/StorageFile.cs)
  • DependencyPropertyDetailsCollection.TryGetPropertyDetails (cognitive 25) (src/Uno.UI/UI/Xaml/DependencyPropertyDetailsCollection.cs)
  • Duplicated block (37–38 lines × 2) (src/Uno.UI.DevServer.Cli/Mcp/McpStdioServer.cs)
  • …and 187 more

New (1512)

  • BrowserInvisibleTextBoxViewExtension.createInput (cognitive 20) (src/Uno.UI.Runtime.WebAssembly.Browser/ts/Runtime/BrowserInvisibleTextBoxViewExtension.ts)
  • Change coupling: Given_ContentDialog.cs ↔ Given_MenuFlyout.cs (src/Uno.UI.RuntimeTests/Microsoft/UI/Xaml/Controls/Given_ContentDialog.cs)
  • Change coupling: Given_ItemsRepeater_Leak.cs ↔ Given_BindingStaleHandlers.cs (src/Uno.UI.RuntimeTests/Microsoft/UI/Xaml/Controls/Repeater/Given_ItemsRepeater_Leak.cs)
  • Change-coupling hub: WebGpuBackend.cs → WebGpuBrowserGraphicsContext.cs, WebGpuJsInterop.cs, WebGpuDevice.cs, WebGpuPathAtlas.cs (src/Uno.UI.Composition.WebGpu/WebGpuBackend.cs)
  • ClassTooLong: DependencyProperty (src/Uno.UI/UI/Xaml/DependencyProperty.cs)
  • ClassTooLong: McpStdioServer (src/Uno.UI.DevServer.Cli/Mcp/McpStdioServer.cs)
  • DeadPreprocessorBranch (src/Uno.UI.Runtime.AppleUIKit/UI/Xaml/Controls/TextBox/InvisibleTextBoxLoupe.cs)
  • DependencyObject.ClearCollectibleAssociatedParent (cyclomatic 17) (src/Uno.UI/UI/Xaml/DependencyObject.alc.cs)
  • DependencyObject.SetChildrenBindableValue (cognitive 21) (src/Uno.UI/UI/Xaml/DependencyObject.Binder.cs)
  • DependencyObject.SetChildrenBindableValue (cyclomatic 22) (src/Uno.UI/UI/Xaml/DependencyObject.Binder.cs)
  • Documentation: no build, run or usage example (src/SolutionTemplate/5.3/uno53AppWithLib/uno53AppWithLib/ReadMe.md)
  • Documentation: no build, run or usage example (src/SolutionTemplate/5.3/uno53net9blank/uno53net9blank/ReadMe.md)
  • Documentation: no build, run or usage example (src/SolutionTemplate/5.6/uno56droidioswasmskia/uno56droidioswasmskia/ReadMe.md)
  • Documentation: no build, run or usage example (src/SolutionTemplate/5.6/uno56net9win32/uno56net9win32/ReadMe.md)
  • Documentation: no build, run or usage example (src/SolutionTemplate/5.6/uno56netcurrent/uno56netcurrent/ReadMe.md)
  • Documentation: no build, run or usage example (src/Uno.UI.Runtime.MacOS/README.md)
  • Duplicated block (10 lines × 2) (src/SourceGenerators/Uno.UI.SourceGenerators/BindableTypeProviders/DependencyObjectAvailabilityGenerator.cs)
  • Duplicated block (10 lines × 2) (src/SourceGenerators/Uno.UI.Tasks/LinkerHintsGenerator/LinkerDescriptorGeneratorTask.cs)
  • Duplicated block (10 lines × 2) (src/Uno.Foundation.Runtime.WebAssembly/Helpers/CompositeDisposable.cs)
  • Duplicated block (10 lines × 2) (src/Uno.Foundation.Runtime.WebAssembly/Helpers/CompositeDisposable.cs)
  • …and 1492 more

Changes since last survey

  • 300 commits — 216 feature/other, 84 fixes

By area

  • (repo) — 86 commits
  • src/Uno.UI.RuntimeTests — 54 commits
  • src/Uno.UI — 36 commits
  • doc/articles — 29 commits
  • build/ci — 9 commits
  • build/nuget — 8 commits
  • src/SamplesApp — 7 commits
  • src/Uno.Sdk — 7 commits
  • src/Uno.UI.Runtime — 6 commits
  • .github/workflows — 5 commits
  • src/Uno.UI.Runtime.Win32 — 5 commits
  • specs/061-hotreload-net11-roslyn-bump — 4 commits
  • src/SourceGenerators — 3 commits
  • src/Uno.UI.Composition — 3 commits
  • src/Uno.UI.Composition.WebGpu — 3 commits
  • src/Uno.UI.Runtime.Linux.FrameBuffer — 3 commits
  • src/Uno.UI.Runtime.X11 — 3 commits
  • (root) — 2 commits
  • doc/import_external_docs.ps1 — 2 commits
  • src/Directory.Packages.props — 2 commits

Notable commits

  • fix: Merge pull request #24168 from shrimqy/clipboard-crash-fix
  • fix: Merge pull request #24171 from morning4coffe-dev/fix/24159-settings-expander-background
  • fix: Merge pull request #25484 from Nacl-HCl/fix/composition-stroke-miter-default-25351
  • fix: Merge pull request #25511 from brunoapolinariodev/fix/gridlength-helper-double-precision
  • fix: Merge pull request #25830 from vantaflow/fix/ported-controls-onpropertychanged2
  • fix: fix(a11y): Release queued owners when the dispatcher is gone
  • fix: fix(alc): Drop the DataContext of a collected associated parent
  • fix: fix(android): Keep window host on activity finish
  • fix: fix(android): Release a11y scroll subscriptions on detach
  • fix: fix(android): don't bind a hosted ALC window to the activity's native window
  • fix: fix(application): initialize pending windows from a snapshot
  • fix: fix(automation): Default AutomationProperties strings to empty
  • fix: fix(automation): Pass owner to LoopingSelectorItem peer
  • fix: fix(automation): Port DatePickerFlyoutItem string representation
  • fix: fix(binder): Keep a released child's DataContext while still held
  • fix: fix(binder): Stop shared values retaining owners
  • fix: fix(binding): Follow a replaced indexed collection
  • fix: fix(binding): Refresh indexers on CollectionChanged
  • fix: fix(build): Add the 7.0 PackageDiffIgnore set
  • fix: fix(ci): Keep hand-pushed backport commits
  • …and 280 more

API surface

  • Unchanged — 4 HTTP endpoints

Architecture

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

Added containers (1)

  • cli:Uno.UI.RuntimeTests.HRApp

Removed containers (1)

  • cli:Uno.UI.RuntimeTests.HRApp.Skia

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

Survey your own repository

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.

About this page

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