AvaloniaUI/Avalonia

This system is a cross-platform UI framework that provides a comprehensive toolkit for building desktop, mobile, and web applications with a single codebase. It features a modern, high-performance rendering engine with GPU acceleration, a robust data binding system with compiled bindings, and a flexible animation infrastructure. The framework supports a wide range of platforms including Windows, macOS, Linux, Android, iOS, and WebAssembly, while offering deep integration with native system features and hardware.

60 changes.

This period marked a comprehensive architectural overhaul, replacing the legacy Perspex codebase with the modern Avalonia framework. The work involved rebuilding the core property and binding systems, migrating the rendering engine to Skia, and implementing robust, native backends for Windows, Linux, macOS, iOS, and Android. Additionally, the project established a stable foundation for development through centralized dependency management, extensive test coverage, and new tooling like the remote XAML previewer.

62 changes.

This period focused on a comprehensive refactoring of the data binding system, introducing typed bindings, a plugin-based architecture, and a lightweight internal reactive implementation to improve performance and AOT compatibility. Simultaneously, the framework modernized its native backends by adding Metal support for macOS, a GLX backend for X11, and robust input method editor integration for Linux. The release also established a new MSBuild SDK with compiled bindings by default, expanded accessibility via UI Automation, and introduced new controls such as DatePicker, TimePicker, and Flyouts.

65 changes.

This period focused on overhauling the rendering infrastructure with a new GPU-accelerated Composition engine and rewriting the animation system for advanced interpolation. It also modernized core platform capabilities, including a new cross-platform file storage API, a refactored browser backend for .NET 8, and significant improvements to text formatting, layout, and input handling.

45 changes.

This period focused on a comprehensive rewrite of the rendering pipeline, introducing a new Vulkan backend, a binary composition data stream, and advanced media effects like blur and drop shadows. It also established a modern page-based navigation system, added CSS Flexbox-style layouts via FlexPanel, and implemented app-drawn window decorations. Significant efforts were made to enhance cross-platform capabilities, including Wayland support, Android accessibility, and extensive GPU interop samples.

A new sample project, AppWithoutLifetime, has been added to the samples directory. It demonstrates how to initialize and run an Avalonia application without using the standard ApplicationLifetime abstraction, providing a reference for manual lifecycle control.

samples/AppWithoutLifetime · high confidence

Introduces the new Calendar control, allowing users to select single dates, date ranges, or multiple non-contiguous ranges via the SelectionMode property. The control supports month, year, and decade navigation modes, highlights today's date by default, and allows disabling specific dates using the BlackoutDates collection. It includes supporting primitives like CalendarButton and CalendarDayButton for visual interaction, and exposes selection state for accessibility via automation peers.

src/Avalonia.Controls/Calendar · high confidence

The MiniMvvm sample now includes a self-contained MVVM toolkit that does not depend on ReactiveUI. It provides a ViewModelBase class with property change notification, a MiniCommand implementation for synchronous and asynchronous command execution, and extension methods to observe property changes via IObservable, enabling users to build simple view models without external reactive libraries.

samples/MiniMvvm · high confidence

The SafeAreaDemo.Android sample now includes a custom Application class and MainActivity extending Avalonia's Android base classes, along with an AndroidManifest that registers the custom application. It introduces a splash screen experience: a legacy layer-list splash for older Android versions and a modern animated vector splash (avalonia\_anim) for API 31+, configured via styles to show the animated icon and background color during app launch.

samples/SafeAreaDemo.Android · high confidence

A new iOS sample application named SafeAreaDemo has been added to the samples directory. This includes the standard iOS project scaffolding (AppDelegate, Main, Info.plist, Entitlements, and LaunchScreen) to demonstrate safe area handling on iOS devices.

samples/SafeAreaDemo.iOS · high confidence

The SafeAreaDemo sample now includes views that demonstrate automatic safe area padding and input pane awareness. The MainView UI visualizes view bounds, safe area insets, and input pane behavior using an InputPaneAwareDecorator, and provides controls to toggle edge-to-edge display, safe area usage, automatic padding, and system bar visibility, while also allowing theme switching and keyboard interaction testing.

samples/SafeAreaDemo/Views · high confidence

A new desktop sample application for SafeArea has been added, providing a standalone entry point and Windows-specific configuration. The Program.cs file sets up the Avalonia application lifecycle with platform detection and developer tools, while the app.manifest file ensures compatibility with Windows 10 and addresses potential issues with window transparency and embedded controls.

samples/Generators.Sandbox, samples/SafeAreaDemo, samples/SafeAreaDemo.Desktop · high confidence

A new Sandbox sample application has been added to the samples directory, providing a minimal Avalonia desktop app structure. The app initializes a main window and applies the FluentTheme style, serving as a baseline for testing and demonstration purposes.

samples/Sandbox · high confidence

A new 'Simple' visual theme has been added for the ColorPicker and its internal components (ColorView, ColorSpectrum, ColorSlider, ColorPreviewer). This theme provides a complete set of ControlTemplates and shared resources (such as the checkered background for transparency) that can be applied to the ColorPicker to change its appearance, distinct from the existing Fluent theme.

src/Avalonia.Controls.ColorPicker/Themes/Simple · high confidence

Avalonia now supports Vulkan as a graphics backend on Android devices. This change introduces the necessary native interop layer to create Vulkan surfaces using the VK\_KHR\_android\_surface extension and registers the Vulkan platform graphics provider, enabling applications to leverage Vulkan for rendering on Android.

src/Android/Avalonia.Android/Platform/Vulkan · high confidence

The WindowsInteropTest sample now includes a demonstration of embedding Avalonia content within a WinForms application. This is achieved by adding a new \EmbedToWinFormsDemo\ form that hosts an \Avalonia.Win32.Interoperability.WinFormsAvaloniaControlHost\ to display Avalonia controls, and registering a \WinFormsAvaloniaMessageFilter\ in the application entry point to ensure proper message handling between the two frameworks.

samples/interop · high confidence

The PlatformSanityChecks sample now includes a new X11-specific entry point that initializes the X11 platform and runs a suite of threading validations. These checks verify that dispatcher timers fire in the correct order, maintain accurate timing intervals, and correctly enforce UI-thread access rules when signaled from background threads, helping users detect threading issues on X11-based platforms.

samples/PlatformSanityChecks · high confidence

The XEmbedSample directory now includes a working example of embedding an Avalonia application inside a GTK window using the XEmbed protocol. The sample introduces a HarfBuzz workaround to prevent symbol resolution conflicts between HarfBuzzSharp and the system libharfbuzz when used with GtkSharp, configures the Avalonia app to use the GLib main loop, and provides a custom Gtk.Socket wrapper (AvaloniaXEmbedGtkSocket) that manages the Avalonia plug, handles background color synchronization, and implements smooth interactive resizing.

samples/XEmbedSample · high confidence

The HTML-based remote designer transport now includes model classes to capture and serialize mouse clicks, pointer movement, and wheel scrolling events. New files in the Input models directory define message structures for pointer-pressed, pointer-released, pointer-moved, and scroll actions, including modifier keys (Alt, Control, Shift, Windows) and specific mouse buttons. These models enable the designer to receive detailed user input interactions from the web app, improving the fidelity of mouse and scroll behavior in the remote design surface.

src/Avalonia.DesignerSupport/Remote/HtmlTransport/webapp/src/Models · high confidence

The ControlCatalog sample now includes platform-specific demos for embedding native controls within Avalonia windows. On Windows, it demonstrates embedding a Rich Edit control via Win32 APIs; on macOS, it shows embedding a WKWebView using Objective-C interop; and on Linux (GTK), it provides examples of embedding an mplayer video window and a GTK file chooser dialog.

samples/ControlCatalog.Desktop/NativeControls · high confidence

This change introduces a new set of Android-specific automation providers in the \src/Android/Avalonia.Android/Automation\ directory, enabling screen readers like TalkBack to interact with Avalonia UI elements. The implementation adds providers for key accessibility patterns including ExpandCollapse, Invoke, RangeValue, Scroll, SelectionItem, Toggle, and Value. These providers bridge Avalonia's automation peers to Android's \AccessibilityNodeInfoCompat\, allowing users to perform actions such as scrolling, toggling states, selecting items, and modifying text values through voice commands.

src/Android/Avalonia.Android/Automation · high confidence

A new abstract CallbackBase class has been introduced in the Avalonia.MicroCom library to manage the lifecycle of COM callback objects. This class implements IUnknown and IMicroComShadowContainer, providing mechanisms to track managed and native references, handle disposal, and trigger a Destroyed event when an object is no longer referenced from either side, ensuring proper cleanup of underlying native resources.

src/Avalonia.MicroCom · high confidence

This change introduces a new input method framework for Linux X11 applications using DBus. It adds a base class for managing DBus connections and input method states, along with a helper that detects the active IME (Fcitx, Fcitx5, or IBus) via environment variables like AVALONIA\_IM\_MODULE, GTK\_IM\_MODULE, QT\_IM\_MODULE, or XMODIFIERS, and registers the corresponding factory in the dependency injection container.

src/Avalonia.FreeDesktop/DBusIme · high confidence

Users on Linux with X11 can now use Fcitx5 for text input. This change introduces the Fcitx5 integration layer, including enum definitions for capabilities and key states, a wrapper for input context communication, and the main X11 text input method handler. It enables features like preedit text display, cursor positioning, and proper handling of modifier keys and content types (e.g., email, password, numbers) through the Fcitx5 DBus interface.

src/Avalonia.FreeDesktop/DBusIme/Fcitx · high confidence

New PowerShell and Bash scripts (ReplaceNugetCache, ReplaceNugetCacheRelease) have been added to the scripts directory. These tools allow developers to copy built Avalonia assemblies (including Avalonia, Avalonia.Win32, Avalonia.Skia, and Avalonia.Native) from the ControlCatalog.NetCore sample output directly into the local NuGet package cache. This enables users to debug issues in their own applications by using locally built versions of the framework instead of the published NuGet packages.

scripts · high confidence

The \src/Avalonia.Controls/Mixins\ directory now includes \PressedMixin\ and \SelectableMixin\, enabling controls to automatically manage visual states and selection events. \PressedMixin\ attaches to pointer events to toggle the \:pressed\ pseudo-class on input elements, allowing for consistent press-state styling. \SelectableMixin\ subscribes to an \AvaloniaProperty\<bool\>\ (typically \IsSelected\) to toggle the \:selected\ pseudo-class, raise the \IsSelectedChangedEvent\, and request scroll-into-view behavior when focused. These mixins provide a reusable mechanism for controls to expose interaction states to the styling system.

src/Avalonia.Controls/Mixins · high confidence

A new Xcode scheme file has been added for the Avalonia.Native.OSX project, configuring the build and launch actions to target the ControlCatalog.NetCore sample application. This scheme sets the working directory to the samples folder and passes the compiled DLL as a command-line argument, enabling developers to easily build and debug the native macOS library alongside the .NET 8 sample application directly from Xcode.

native/Avalonia.Native/src/OSX/Avalonia.Native.OSX.xcodeproj/xcshareddata · high confidence

New compatibility shim files have been added to Avalonia.Base to support .NET 6+ trimming and nullable reference type analysis on older target frameworks. NullableAttributes.cs provides polyfills for nullability attributes (e.g., AllowNull, DisallowNull, MaybeNull, NotNull, NotNullWhen, NotNullIfNotNull, DoesNotReturn, MemberNotNull) for frameworks prior to .NET 6. TrimmingAttributes.cs provides polyfills for trimming-related attributes (e.g., DynamicallyAccessedMembers, DynamicDependency, RequiresUnreferencedCode, UnconditionalSuppressMessage) for the same older frameworks. ReferenceEqualityComparer.cs adds a polyfill for ReferenceEqualityComparer for .NET Standard 2.0. These changes enable better static analysis and trimming support without requiring runtime changes.

src/Avalonia.Base/Compatibility · high confidence

The Diagnostics namespace now includes a new ToolTipDiagnostics helper class that exposes the internal ToolTip property for use in DevTools, enabling better inspection of tooltip states. Additionally, a new internal IPopupHostProvider interface has been introduced to facilitate the retrieval and monitoring of associated popup hosts, laying the groundwork for diagnostics support for other popup-based elements like Flyouts and ContextMenus.

src/Avalonia.Controls/Diagnostics · high confidence

The ControlCatalog iOS sample now includes a LaunchScreen.xib file, providing a standard iOS launch interface that displays the application title and copyright information during startup.

samples/ControlCatalog.iOS/Resources · high confidence

The \src/Avalonia.Base/Reactive/Operators\ directory now includes new internal implementations for the \CombineLatest\ and \Switch\ reactive operators, along with supporting base classes (\Sink\, \IdentitySink\). These additions provide the underlying logic for combining multiple observables into a single result and for switching to the most recent observable source, respectively, enabling more complex reactive data binding scenarios within Avalonia.

src/Avalonia.Base/Reactive/Operators · high confidence

The ControlCatalog.Android sample now uses a custom Application class to initialize the Avalonia builder, allowing for platform-specific setup such as registering the Android EmbedSample. Additionally, a new DataSchemeActivity has been added to handle 'avln' URI scheme activations, enabling the app to respond to external links or intents targeting this specific protocol.

samples/ControlCatalog.Android · high confidence

The animation engine in Avalonia.Base has been completely rewritten, replacing the previous implementation with a new architecture. This introduces new core classes such as Animatable, Animation, and AnimationInstance, along with a new AnimatorRegistry for managing type-specific interpolators. The system now supports advanced features like PlaybackBehavior (allowing animations to pause when controls are invisible), CompositePageTransition for combining multiple page transitions, and IProgressPageTransition for gesture-driven updates. Transitions are now driven by animators, and the codebase includes new interfaces like IAnimation, IAnimator, and IClock to support this refactored structure.

src/Avalonia.Base/Animation · high confidence

Users can now opt into client-side (app-drawn) window decorations, allowing the application to fully control the appearance of the window frame, title bar, and resize areas. This change introduces the \WindowDrawnDecorations\ component and supporting infrastructure, including a \ResizeGripLayer\ for precise edge resizing, a \TitleBarDecorations\ flag to selectively show or hide title bar elements (title, minimize, maximize, close, and full-screen buttons), and attached properties for hit-testing decoration roles. The system supports configurable title bar height, frame thickness, and shadow thickness, enabling themes to provide a native or custom look while maintaining standard window interaction behaviors.

src/Avalonia.Controls/Chrome · high confidence

The Avalonia.Native backend for macOS has been significantly reorganized and expanded. It now includes a new Metal rendering backend alongside the existing OpenGL and software renderers, with Metal prioritized in the default rendering mode configuration. The platform initialization has been refactored to use a modern factory-based approach (MicroCom) for native interop, replacing older mechanisms. New platform services have been added, including a dedicated drag-and-drop source implementation, a comprehensive native menu exporter supporting application, window, tray, and dock menus, and an updated application platform that handles file/URL activation and shutdown requests via the IActivatableLifetime. Additionally, the backend now features a reworked text input method client for better IME support and a new automation peer implementation to improve accessibility integration.

src/Avalonia.Native · high confidence

The ControlCatalog.Browser sample now provides a complete web entry point with a new splash screen that respects the user's system light or dark theme, and an embedded JavaScript button that tracks click counts. This change adds the necessary HTML, CSS, and JavaScript files to the wwwroot directory to support the browser-based Avalonia UI runtime.

samples/ControlCatalog.Browser/wwwroot · high confidence

The ControlCatalog.Desktop entry point has been rewritten to support multiple display backends via command-line flags. Users can now run the sample on Linux DRM devices (--drm), Linux framebuffer devices (--fbdev), or via VNC headless mode (--vnc), in addition to standard desktop modes. The application also supports scaling and orientation arguments for DRM, and includes a full-headless mode for automated UI testing and memory profiling. The sample is configured to use Skia, Vulkan, and Wayland with fallback, and includes a Windows application manifest targeting Windows 10.

samples/ControlCatalog.Desktop · high confidence

The Avalonia.Base assembly now registers a set of default XML namespaces (https://github.com/avaloniaui) that map to core Avalonia namespaces such as Avalonia, Avalonia.Controls, Avalonia.Data, Avalonia.Input, Avalonia.Layout, Avalonia.Media, and others. This allows XAML files to reference these types without requiring explicit xmlns declarations for each namespace, simplifying markup authoring.

src/Avalonia.Base/Properties · high confidence

The RenderDemo application now includes new pages to showcase recent rendering and animation capabilities. The AnimationSpeedPage and AnimationsPage demonstrate animation controls, including speed ratios, playback directions, iteration counts, and complex keyframe animations for properties like BoxShadow and gradient brushes. The DrawingPage illustrates DrawingImage stretching modes, while the FormattedTextPage and GlyphRunPage display text rendering, geometry building, and highlight geometry. Additionally, the GeometryHitTestingPage and HitTestingPage provide interactive examples for visual and geometry-based hit testing, and the CustomAnimatorPage shows how to implement custom string interpolation in animations.

samples/RenderDemo/Pages · high confidence

The ColorPicker, ColorView, ColorSpectrum, ColorSlider, and ColorPreviewer controls now have dedicated Fluent UI theme definitions. This adds the visual styling for the color picker interface, including the main picker button, the tabbed view for selecting colors (spectrum, palette, components), the color preview with drop shadow, and the individual sliders and spectrum controls.

src/Avalonia.Controls.ColorPicker/Themes/Fluent · high confidence

The Fluent theme now supports dynamic system accent colors that automatically adjust to the user's OS theme settings, providing a more native look and feel. This is achieved through the new \SystemAccentColors\ resource provider, which calculates light and dark shades of the accent color based on system values. Additionally, a new \ColorPaletteResources\ API allows developers to customize the theme's color palette, including the accent color, by setting properties on the \FluentTheme.Palettes\ collection. This change enhances the theme's flexibility and ensures better integration with system-wide color schemes.

src/Avalonia.Themes.Fluent · high confidence

Immutable brush, pen, and transform classes in Avalonia.Base now include support for relative transforms and transform origins. This allows developers to apply coordinate-space transformations to gradients, solid colors, image brushes, and pens that are calculated relative to the area being painted, rather than only in absolute coordinates. The change also introduces immutable versions of dash styles and text decorations to maintain consistency across the media API.

src/Avalonia.Base/Media/Immutable · high confidence

This change introduces the foundational provider interfaces in the \Avalonia.Automation.Provider\ namespace that enable UI Automation clients (such as screen readers) to interact with Avalonia controls. The new files define contracts for core accessibility patterns including \IRootProvider\ and \IEmbeddedRootProvider\ for tree navigation, \IExpandCollapseProvider\ for expandable controls, \IInvokeProvider\ for actions, \IRangeValueProvider\ and \IValueProvider\ for data values, \IScrollProvider\ for scrolling, \ISelectionProvider\ and \ISelectionItemProvider\ for list selection, and \IToggleProvider\ for toggle states. These interfaces map to Windows UI Automation and macOS Accessibility protocols, providing the necessary hooks for assistive technologies to access and control UI elements.

src/Avalonia.Controls/Automation/Provider · high confidence

This change introduces the foundational UI Automation infrastructure for Avalonia, enabling screen readers and accessibility tools to interact with the application. It adds a comprehensive set of AutomationPeers for built-in controls (including Button, ComboBox, Calendar, Expander, and various Page types) and defines the core AutomationControlType and AutomationLandmarkType enums. Users will now have basic accessibility support, allowing assistive technologies to identify control types, read names and help text, and interact with standard UI elements like expanding menus or selecting list items.

src/Avalonia.Controls/Automation/Peers · high confidence

This change introduces the foundational UI Automation infrastructure in Avalonia, enabling compatibility with screen readers and other assistive technologies on platforms like iOS (VoiceOver) and Android (TalkBack). It adds the \AutomationProperties\ attached properties (such as \AutomationId\, \HelpText\, \LandmarkType\, and \HeadingLevel\) to expose control metadata, defines \AutomationElementIdentifiers\ for standard properties, and implements core automation patterns including ExpandCollapse, RangeValue, Scroll, Selection, Toggle, and Value. Additionally, it provides \AutomationLiveSetting\ to control how dynamic content updates are announced to users.

src/Avalonia.Controls/Automation · high confidence

This change introduces the first implementation of iBus-based input method support for Avalonia applications running on X11. It adds the necessary DBus communication layer, including enum definitions for modifier masks and capabilities, and implements the \IBusX11TextInputMethod\ class to handle key events, text commits, and preedit text updates via the iBus DBus protocol.

src/Avalonia.FreeDesktop/DBusIme/IBus · high confidence

Introduces the core components for the remote XAML previewer, including the \RemoteServer\ class which manages the remote rendering lifecycle and the \RemoteWidget\ control which displays streamed frames. The \RemoteWidget\ handles pixel format negotiation (Bgra8888/Rgba8888), manages bitmap allocation and disposal to prevent memory leaks, and supports both local and remote sizing modes, enabling the display of remote UI content within the desktop environment.

src/Avalonia.Controls/Remote · high confidence

This change introduces the core JavaScript/TypeScript modules that power the Avalonia Browser runtime, enabling .NET applications to run in the web. It includes DOM management for creating and attaching HTML canvases, a rendering pipeline supporting both 2D software and WebGL rendering targets, and comprehensive input handling for keyboard, mouse, and clipboard operations (including a workaround for older Firefox versions). Additionally, it provides helpers for screen detection, safe area insets, system theme detection, timers, and file stream interactions.

src/Browser/Avalonia.Browser/webapp/modules/avalonia · high confidence

This change introduces the core infrastructure for Avalonia's remote previewer, enabling real-time XAML design-time updates and input interaction (mouse/keyboard) from external tools. It embeds the Metsys.Bson serializer to handle message serialization over TCP, defines a set of typed protocol messages for viewport management, frame rendering, and designer sessions, and implements the transport layer with connection handling and event queuing.

src/Avalonia.Remote.Protocol · high confidence

Applications can now opt into the HarfBuzz text shaping engine by calling \UseHarfBuzz\ on the \AppBuilder\. This change introduces the \HarfBuzzTextShaper\ and \HarfBuzzTypeface\ implementations, which handle complex script rendering, bidirectional text layout, and glyph positioning via the HarfBuzz library, providing more accurate text shaping than the default subsystem.

src/HarfBuzz · high confidence

The \src/Avalonia.Base/Collections/Pooled\ directory now contains internal implementations of \PooledList\<T\>\ and \PooledStack\<T\>\, along with supporting types like \ClearMode\ and \IReadOnlyPooledList\<T\>\. These collections use \ArrayPool\<T\>\ to manage memory, offering a performance-optimized alternative to standard lists and stacks for internal framework operations. Because these types are marked \internal\, they are not part of the public API and are intended for use within the Avalonia framework itself.

src/Avalonia.Base/Collections/Pooled · high confidence

Avalonia now exposes its UI tree to assistive technologies on Linux via the AT-SPI2 protocol. This new backend registers the application and its windows on the D-Bus session bus, maps Avalonia automation peers to AT-SPI roles and states, and monitors for active screen readers to optimize event emission. Users with screen readers will now be able to navigate and interact with Avalonia applications using standard Linux accessibility tools.

src/Avalonia.FreeDesktop.AtSpi · high confidence

A new Avalonia.Fonts.Inter package has been introduced to provide the Inter font family. Users can now easily enable this font by calling the new global WithInterFont extension method on the AppBuilder, which registers the Inter font collection. This replaces the previous approach of using Avalonia.Themes.Fluent.Inter and moves the font configuration into a dedicated, globally accessible namespace.

src/Avalonia.Fonts.Inter · high confidence

This change adds a new set of internal classes in the \Avalonia.Platform.Storage.FileIO\ namespace that provide a baseline implementation of the \IStorageProvider\ and \ILauncher\ interfaces using the .NET Base Class Library. The new \BclStorageProvider\ exposes standard file picker and folder picker operations, while \BclStorageFile\, \BclStorageFolder\, and \BclStorageItem\ wrap \System.IO\ types to expose file system properties and operations like reading, writing, moving, and deleting. Additionally, \BclLauncher\ handles URI and file launching across Windows, macOS, and Linux (using \xdg-open\), and \StorageBookmarkHelper\ manages cross-platform bookmark encoding and decoding to persist file and folder references.

src/Avalonia.Base/Platform/Storage/FileIO · high confidence

A new ColorView control has been added to the Avalonia.Controls.ColorPicker namespace, providing a dedicated component for color editing that includes a color spectrum, palette, and component sliders. This control introduces extensive configurability via boolean properties (such as IsAccentColorsVisible, IsAlphaEnabled, IsColorModelVisible, and IsHexInputVisible) that allow users to show or hide specific UI sections like the hex input box, alpha channel controls, and color model selectors. It also supports switching between color models, configuring the position of the alpha component in hex strings, and exposes a ColorChanged event to track user selections.

src/Avalonia.Controls.ColorPicker/ColorView · high confidence

The CommandBar control is now available, providing a container for primary commands displayed inline and secondary commands accessible via an overflow menu. This implementation supports dynamic overflow, allowing primary commands to move to the overflow popup when space is limited, with configurable sizing and label positioning (Bottom, Right, or Collapsed). The control includes dedicated element types (CommandBarButton, CommandBarToggleButton, CommandBarSeparator) and supports keyboard navigation for the overflow popup, along with events for opening and closing the menu.

src/Avalonia.Controls/CommandBar · high confidence

A new EmbeddableControlRoot class has been added to the Avalonia.Controls.Embedding namespace, providing a TopLevel-based container designed for embedding Avalonia UI within other applications. It supports initialization via Prepare(), manages its own layout and rendering lifecycle, enforces client size constraints, and implements IDisposable for proper resource cleanup, including disposal of the underlying platform implementation.

src/Avalonia.Controls/Embedding · high confidence

A new FlexPanel control is added to Avalonia.Controls, enabling child elements to be arranged using CSS Flexbox principles. This includes support for main-axis direction (Row/Column), alignment (JustifyContent, AlignItems, AlignContent), wrapping behavior, and spacing (RowSpacing, ColumnSpacing). Developers can also fine-tune individual child items using attached properties for order, basis, grow, shrink, and cross-axis alignment overrides.

src/Avalonia.Controls/FlexPanel · high confidence

This change adds the \Flyout\, \MenuFlyout\, \FlyoutBase\, and \PopupFlyoutBase\ classes to the \Avalonia.Controls\ namespace, providing a new way to display contextual overlays. Users can now define flyout content via \Content\ and \ContentTemplate\ properties, or populate a \MenuFlyout\ with \Items\ or \ItemsSource\. The implementation supports advanced placement options inherited from \Popup\ (such as \Placement\, \HorizontalOffset\, and \CustomPopupPlacementCallback\) and introduces \FlyoutShowMode\ to control focus behavior (Standard vs. Transient). Additionally, developers can apply specific \ControlTheme\ instances to the flyout presenter (\FlyoutPresenterTheme\) and its items (\ItemContainerTheme\ for \MenuFlyout\), allowing for deep visual customization of these new UI components.

src/Avalonia.Controls/Flyouts · high confidence

Adds new \OffscreenTopLevel\ and \OffscreenTopLevelImplBase\ classes to the \Avalonia.Controls.Embedding.Offscreen\ namespace, enabling the creation of Avalonia visual trees without a native window. This allows for headless rendering scenarios, such as generating images or running UI logic in a server environment, by providing a local layout manager and compositor implementation.

src/Avalonia.Controls/Embedding/Offscreen · high confidence

A new PipsPager control is added to Avalonia.Controls, allowing users to navigate through a paginated collection via a set of indicator pips. The control exposes properties to configure the number of pages, the maximum visible pips, the orientation (horizontal or vertical), and the visibility of previous/next navigation buttons. It also provides a SelectedIndexChanged event to react to page changes and exposes template settings to support custom theming of the pip indicators.

src/Avalonia.Controls/PipsPager · high confidence

This change adds a new XYFocus system to Avalonia, enabling 2D directional navigation (up, down, left, right) for keyboard arrow keys, gamepads, and remote controls. It introduces attached properties (e.g., \XYFocus.Down\, \XYFocus.NavigationStrategy\) to configure focus targets and strategies (Projection, RectilinearDistance, etc.), and implements the underlying algorithms to rank and select the next focusable element based on geometric proximity and manifold logic. This allows applications to support console-like or TV-style navigation flows beyond standard Tab/Shift+Tab traversal.

src/Avalonia.Base/Input/Navigation · high confidence

A new managed file dialog implementation has been added to the internal dialogs layer, providing a cross-platform file picker and saver that does not rely on native OS windowing systems. This change introduces a suite of internal view models (including \ManagedFileChooserViewModel\, \ManagedFileChooserItemViewModel\, and \ManagedFileChooserFilterViewModel\) and supporting infrastructure such as a BCL-based volume info provider and file size converters. For users, this enables consistent file selection and saving behavior across different platforms by handling navigation, filtering, and selection logic entirely within the managed codebase.

src/Avalonia.Dialogs/Internal · high confidence

The notification subsystem has been refactored to support arbitrary content and multiple notification types (Information, Success, Warning, Error) via new \INotification\ and \IManagedNotificationManager\ interfaces. \WindowNotificationManager\ now allows notifications to be displayed in six positions (TopLeft, TopRight, BottomLeft, BottomRight, TopCenter, BottomCenter) and supports custom style classes. The UI is driven by a new \NotificationCard\ control and a \ReversibleStackPanel\ for layout, enabling features like close-on-click buttons and automatic expiration timers.

src/Avalonia.Controls/Notifications · high confidence

A new \IStorageProvider\ API has been added to \Avalonia.Platform.Storage\, replacing older mechanisms with a unified, async-first interface for file and folder operations. This includes dedicated options classes (\FilePickerOpenOptions\, \FilePickerSaveOptions\, \FolderPickerOpenOptions\) and result types (\OpenFilePickerResult\, \SaveFilePickerResult\) that support features like multi-select, suggested file types, and overwrite prompts. The update introduces a \FallbackStorageProvider\ to gracefully handle platform variations by trying multiple providers, and adds a \FilePickerFileTypes\ static class with pre-defined common types (e.g., images, PDFs, JSON) to simplify dialog configuration. Additionally, a new \ILauncher\ interface allows applications to open files or URIs with their default associated apps, and bookmarking support (\IStorageBookmarkItem\) enables persistent access to previously selected items.

src/Avalonia.Base/Platform/Storage · high confidence

The remote previewer now uses a dedicated framebuffer implementation in RemoteServerTopLevelImpl to manage pixel data, DPI scaling, and frame transmission to clients. This change enables proper high-DPI support and allows the server to receive and process mouse and keyboard input events from the remote client, translating protocol messages into native Avalonia input events.

src/Avalonia.Controls/Remote/Server · high confidence

The XAML previewer now supports a new web-based transport layer that renders previews in an HTML canvas via WebSocket, enabling high-DPI scaling and handling mouse and wheel input events. This change adds a security cookie mechanism to validate the connection and replaces the previous webpack build process with esbuild for faster compilation.

src/Avalonia.DesignerSupport/Remote/HtmlTransport/webapp/src · high confidence

The ColorPicker control now includes the core type definitions required to support color selection, specifically adding the \ColorModel\ enum (supporting HSV and RGB modes), specific component enums (\RgbComponent\, \HsvComponent\, \ColorComponent\), and the \AlphaComponentPosition\ enum to define alpha channel ordering. Additionally, a new \ColorChangedEventArgs\ class has been added to provide detailed information about color changes, including both the old and new \Color\ values, enabling consumers to track state transitions accurately.

src/Avalonia.Controls.ColorPicker · high confidence

This change adds a new managed file chooser implementation that allows applications to use a cross-platform, UI-native file picker instead of relying on native OS dialogs or xdg-desktop-portal. Users can enable this via the new \UseManagedSystemDialogs\ extension on \AppBuilder\, which supports custom root containers (windows or popups) and an overwrite confirmation prompt for save operations. Additionally, a new \AboutAvaloniaDialog\ window is provided to display the Avalonia version and copyright information with a link to the official website.

src/Avalonia.Dialogs · high confidence

This change introduces the foundational \Avalonia.Base\ library, establishing the core property system and service location infrastructure. It adds the \AvaloniaObject\ class for dependency property support, including \AvaloniaProperty\, \AvaloniaPropertyRegistry\, and \ValueStore\ for value management, along with \AttachedProperty\ for attached property support. The diff also introduces \AvaloniaLocator\ and \IAvaloniaDependencyResolver\ to provide a built-in dependency injection mechanism for service resolution. Additionally, it includes utility classes for animation easing (\BounceEaseUtils\, \EasingUtils\) and extension methods for binding observables (\AvaloniaObjectExtensions\).

src/Avalonia.Base · high confidence

The rendering engine now includes a new set of internal server-side classes (e.g., \ServerCompositionBrush\, \ServerCompositionSimpleBrush\) and their corresponding UI-side wrappers (e.g., \CompositionBrush\, \CompositionGradientBrush\) to handle brush serialization and state management. This change introduces support for gradient stops and spread methods in the composition layer, enabling more complex brush definitions to be processed by the rendering server.

src/Avalonia.Base/Rendering/Composition/Brushes · high confidence

The rendering engine now supports custom draw operations via the new ICustomDrawOperation interface, allowing external code to define custom geometry and rendering logic within the scene graph. This interface includes methods for hit testing against specific points or geometries and rendering via an ImmediateDrawingContext. Additionally, a new LineBoundsHelper class has been added to accurately calculate the bounding rectangles for lines, taking into account pen thickness and line cap styles to ensure correct layout and hit-testing behavior.

src/Avalonia.Base/Rendering/SceneGraph · high confidence

A new logging infrastructure has been added to Avalonia.Base, replacing the previous direct logging functions with a structured system. This includes the ILogSink interface, a Logger class for centralized access, and a LogArea class defining specific areas such as Property, Binding, Animations, and various platform identifiers (e.g., WinUIPlatform, BrowserPlatform). The system supports filtering logs by both severity level (LogEventLevel) and specific areas, allowing users to enable or disable logging for particular subsystems. A default StringLogSink implementation is provided to format and output these structured log messages.

src/Avalonia.Base/Logging · high confidence

Avalonia now includes a new Composition rendering engine in Avalonia.Base, providing a modern, GPU-accelerated rendering path alongside existing renderers. This system introduces a new visual tree API (CompositionVisual, Compositor) that supports advanced features such as hardware-accelerated animations, GPU interop for importing external textures, and optimized hit-testing with per-visual AABBs. It also adds support for opacity masks on VisualBrush, custom drawing via CompositionCustomVisual, and configurable dirty-rect clipping to improve rendering performance.

src/Avalonia.Base/Rendering/Composition · high confidence

The \src/Avalonia.Vulkan\ directory now contains the complete source code for the new Vulkan rendering backend. This change introduces the core infrastructure required for Vulkan support, including low-level interop wrappers for Vulkan objects (such as \VulkanDevice\, \VulkanInstance\, \VulkanCommandBuffer\, and \VulkanImage\), platform surface abstractions (\IVulkanKhrSurfacePlatformSurface\), and the swapchain management logic in \VulkanDisplay\. This codebase replaces the previous implementation to provide a more robust foundation for rendering.

src/Avalonia.Vulkan · high confidence

The \src/Avalonia.Base/Media\ namespace has been significantly restructured to support modern rendering and text layout. New enums have been introduced to control layout and appearance, including \AcrylicBackgroundSource\ (with a \Digger\ mode), \BackgroundSizing\ (supporting \InnerBorderEdge\, \OuterBorderEdge\, and \CenterBorder\), \AlignmentX/Y\, \BaselineAlignment\, and \BaselinePixelAlignment\. Path drawing capabilities are expanded with new \PathSegment\ types like \ArcSegment\ and \BezierSegment\, alongside a comprehensive \BoxShadow\ and \BoxShadows\ implementation for drop shadows. The \Brush\ class now supports \TransformOrigin\ and \RelativeTransform\ properties, and the \BitmapCache\ class has been updated to integrate with the composition system, allowing for configurable render scales and ClearType support.

src/Avalonia.Base/Media · high confidence

The new AccessText control in Avalonia.Controls.Primitives allows developers to display text with an underlined access key (indicated by an underscore). It automatically registers the extracted key with the window's access key handler, enabling users to activate associated controls via keyboard shortcuts, and supports toggling the visual underline via the ShowAccessKey property.

src/Avalonia.Controls/Primitives · high confidence

The Android platform now supports the modern IStorageProvider API, enabling file and folder operations via the Android Storage Access Framework. This change introduces new classes (AndroidStorageItem, AndroidStorageFolder, AndroidStorageFile) to handle content and file URIs, allowing users to open, save, and manage files and folders on Android devices running API level 19 or higher.

src/Android/Avalonia.Android/Platform/Storage · high confidence

Avalonia introduces \AvaloniaList\<T\>\ and \AvaloniaDictionary\<TKey, TValue\>\ as new notifying collection types in \Avalonia.Base.Collections\. \AvaloniaList\ adds \Move\, \MoveRange\, \RemoveAll\, and \RemoveRange\ operations, allows configuring \ResetBehavior\ to send individual \Remove\ notifications instead of a \Reset\ on clear, and supports item validation via a \Validate\ callback. \AvaloniaDictionary\ provides a notifying dictionary implementation with \CollectionChanged\ and \PropertyChanged\ events. Both types are supported by extension methods (\ForEachItem\, \TrackItemPropertyChanged\) and weak subscription helpers (\WeakSubscribe\) to manage change notifications efficiently.

src/Avalonia.Base/Collections · high confidence

This change introduces a new media effects system in Avalonia.Base/Media/Effects, adding BlurEffect and DropShadowEffect (including a WPF-compatible DropShadowDirectionEffect) that can be applied to visual elements. The implementation includes immutable effect types, a string-based parser for XAML declarations, and full integration with the animation system via EffectAnimator and EffectTransition, allowing properties like blur radius, shadow offset, color, and opacity to be animated smoothly.

src/Avalonia.Base/Media/Effects · high confidence

The \src/Avalonia.Base/Media/Transformation\ directory now contains a new implementation for handling CSS-style transform strings, including \InterpolationUtilities\, \TransformOperations\, and \TransformParser\. This introduces support for parsing complex transform functions (translate, scale, rotate, skew, matrix) with unit awareness and enables smooth interpolation between transform states for animations, following CSS Transforms Level 1 specifications. The \TransformParser\ is internal, while \TransformOperations\ provides the public API for creating, parsing, and interpolating transform operations.

src/Avalonia.Base/Media/Transformation · high confidence

A new ColorPicker control has been added to the Avalonia.Controls namespace, extending the existing ColorView to provide a UI for color editing via a spectrum, palette, and component sliders within a drop-down flyout. This control introduces customizable preview content through standard Content, ContentTemplate, and alignment properties, allowing developers to define what is displayed in the closed state before the user opens the picker.

src/Avalonia.Controls.ColorPicker/ColorPicker · high confidence

A new \ColorPreviewer\ control has been added to the \Avalonia.Controls.Primitives\ namespace, allowing users to preview a selected color and adjust it using accent colors. The control exposes an \HsvColor\ property (defaulting to transparent, two-way bound) to track the current color and an \IsAccentColorsVisible\ property to toggle the visibility of accent color buttons. When accent colors are visible, clicking the associated borders adjusts the \HsvColor\ by predefined steps via the \AccentColorConverter\, raising a \ColorChanged\ event to notify consumers of the update.

src/Avalonia.Controls.ColorPicker/ColorPreviewer · high confidence

The Composition rendering layer now includes a new animation infrastructure in Avalonia.Base, introducing ExpressionAnimation for frame-by-frame mathematical calculations and KeyFrameAnimation for time-based interpolation with easing. This change adds the core classes required to define, group, and trigger animations (including ImplicitAnimationCollection), along with the necessary interpolators for vector, color, and scalar types, enabling developers to drive visual changes via property expressions or keyframe sequences.

src/Avalonia.Base/Rendering/Composition/Animations · high confidence

Avalonia now includes new DatePicker and TimePicker controls for selecting dates and times. These controls feature a popup interface with scrollable, touch-friendly selectors for year, month, day, hour, minute, and optional seconds. The implementation introduces a shared DateTimePickerPanel for the scrolling lists, supports 12-hour and 24-hour clock formats, and allows customization of date/time display formats and value ranges. The controls also support two-way data binding and data validation for the selected values.

src/Avalonia.Controls/DateTimePickers · high confidence

Avalonia introduces a new EGL-based rendering backend for OpenGL, providing native OpenGL support on Linux and Android. This implementation includes a complete EGL interface layer, context and display management, and surface handling for both window and offscreen rendering. It supports multiple OpenGL versions (ES 1/2/3 and desktop profiles), context sharing, and includes workarounds for specific driver quirks (such as NVIDIA EGL drivers). The backend also enables interop with externally managed GPU memory via EGLImage and supports platform-specific features like Wayland and DRM.

src/Avalonia.OpenGL/Egl · high confidence

The X11 platform now includes a dedicated GLX backend for OpenGL rendering, introducing new classes in the \Glx\ namespace (\GlxDisplay\, \GlxContext\, \GlxGlPlatformSurface\) to manage OpenGL contexts, surfaces, and rendering sessions. This is accompanied by a new dispatching architecture in \src/Avalonia.X11/Dispatching\, featuring \GlibDispatcherImpl\ for GLib-based event loops and \X11PlatformThreading\ for epoll-based threading, alongside an \ActivityTrackingHelper\ to improve window activation state tracking.

src/Avalonia.X11 · high confidence

The GpuInterop sample has been rewritten to demonstrate GPU interop using the Composition API, supporting both Vulkan (default) and D3D11 rendering backends. The application now uses a new \DrawingSurfaceDemoBase\ class to manage \CompositionDrawingSurface\ resources and integrates with the compositor for frame updates. Platform-specific native interop is handled via P/Invoke calls to IOSurface on macOS, while the main window allows switching between Vulkan and D3D11 modes via command-line arguments or initialization parameters.

samples/GpuInterop · high confidence

The designer now supports a new HTML-based previewer transport that serves a web application via a local WebSocket server. This change introduces \HtmlWebSocketTransport\ and \SimpleWebSocketHttpServer\ to handle HTTP requests for static assets (HTML, JS, CSS) and WebSocket connections for real-time communication. A security measure is included where a unique secret cookie is injected into the served \index.html\ to validate the WebSocket connection origin, ensuring that only authorized clients (such as VS Code webviews or matching origins) can connect to the previewer.

src/Avalonia.DesignerSupport/Remote/HtmlTransport · high confidence

The ControlCatalog samples now include a new HamburgerMenu control that provides a navigation pane with a built-in search box. The control automatically sorts its items alphabetically and filters them in real-time as the user types. It also adapts its layout behavior, switching between inline and overlay modes based on the window width, and automatically closes the pane when an item is selected in overlay mode.

samples/SampleControls · high confidence

A new ItemContainerGenerator class has been added to the Avalonia.Controls.Generators namespace to handle the lifecycle of item containers within ItemsControl. This class provides methods to determine if an item needs a container, create and prepare containers, handle container recycling via recycle keys, and manage index changes. It serves as the central coordinator for generating and clearing item containers, delegating the tracking of realized containers to the items panel, which supports features like virtualization and heterogeneous item containers.

src/Avalonia.Controls/Generators · high confidence

The Linux framebuffer platform now supports direct input handling via libinput and evdev, replacing the previous input model. This change introduces a new \EpollDispatcherImpl\ for more accurate event loop timing, and adds \LibInputBackend\ and \EvDevBackend\ to handle pointer, touch, and wheel events from Linux input devices. A \NullInputBackend\ is also provided for headless or input-less scenarios. These components are wired into the \LinuxFramebufferPlatform\ to enable full interactive support on bare-metal or framebuffer-based Linux systems.

src/Linux · high confidence

The build system now includes dedicated MSBuild tasks to handle XAML compilation and resource packaging. The new CompileAvaloniaXamlTask orchestrates the XAML compiler, supporting features like IL verification, strong-name signing, and debugger attachment. The GenerateAvaloniaResourcesTask processes Avalonia resources, pre-processing XAML files to detect duplicate x:Class directives and packing them into a binary index. Supporting infrastructure includes a ComInteropHelper for patching interop assemblies, a DeterministicIdGenerator for reproducible builds, and an XamlCompilerDiagnosticsFilter that respects .editorconfig settings for diagnostic severity.

src/Avalonia.Build.Tasks · high confidence

Avalonia introduces a new base class, OpenGlControlBase, for OpenGL rendering that integrates with the visual compositor. This change replaces previous rendering mechanisms with a system that manages OpenGL contexts, framebuffers, and swapchains via CompositionOpenGlSwapchain and OpenGlControlResources. Users can now create custom OpenGL controls by inheriting from OpenGlControlBase, which handles context lifecycle, surface creation, and rendering synchronization automatically, ensuring proper OpenGL context management and cleanup within the compositor's rendering pipeline.

src/Avalonia.OpenGL/Controls · high confidence

A new set of APIs has been introduced to allow OpenGL contexts to interoperate with the Avalonia Composition engine. This includes the \OpenGlCompositionInterop.TryCreateCompatibleGlContextAsync\ extension method for creating compatible contexts, along with \ICompositionGlContext\ and \ICompositionGlTexture\ interfaces that manage texture lifecycles, drawing leases, and asynchronous presentation to composition surfaces. This enables developers to render OpenGL content directly into the visual tree.

src/Avalonia.OpenGL/Composition · high confidence

A new RefreshContainer control has been added to Avalonia.Controls, providing built-in pull-to-refresh functionality for scrollable content. This container automatically detects and adapts to nested ScrollViewer instances, supporting both touch and mouse gestures (via the IsMouseEnabled property) and configurable pull directions (TopToBottom, BottomToTop, LeftToRight, RightToLeft). It exposes a RefreshRequested event with a deferral-based API (RefreshCompletionDeferral) to manage asynchronous refresh operations, and includes a RefreshVisualizer component that displays a state-aware indicator (Idle, Peeking, Interacting, Refreshing) with smooth Composition API animations.

src/Avalonia.Controls/PullToRefresh · high confidence

The \src/tools\ directory now includes the \Avalonia.Analyzers.CSharp\ package, introducing compile-time diagnostics to improve code quality and catch common mistakes. The \AvaloniaPropertyAnalyzer\ checks for correct registration and storage of Avalonia properties (e.g., ensuring they are static/readonly, owned by the correct type, and have matching CLR accessors). A new \BitmapAnalyzer\ warns against initializing \Bitmap\ objects directly from \avares://\ URIs, enforcing the use of \AssetLoader\. Additionally, \GeneratedPropertyAnalyzer\ validates the new \\[GeneratedStyledProperty\]\, \\[GeneratedDirectProperty\]\, and \\[GeneratedAttachedProperty\]\ attributes, while \ConvertToGeneratedPropertyAnalyzer\ suggests migrating manual property declarations to the generated equivalents.

src/tools · high confidence

The samples/SingleProjectSandbox directory now contains a complete, runnable sample application demonstrating the single-project multi-targeting pattern. It includes platform-specific entry points and configurations for Desktop (Windows), Android, iOS, macOS, and WebAssembly (Browser), along with a shared UI featuring a login view with various TextBox configurations.

samples/SingleProjectSandbox · high confidence

A new SplitButton control is introduced, providing a composite button with a primary action part (behaving like a standard Button) and a secondary part that opens a Flyout. It supports ICommand binding, CommandParameter, and HotKey gestures. A derived ToggleSplitButton variant is also added, which behaves like a ToggleButton with two-state IsChecked binding and an IsCheckedChanged event, while sharing the same default style as the standard SplitButton.

src/Avalonia.Controls/SplitButton · high confidence

A new sample application (TextTestApp) has been added to the samples directory to demonstrate and test text formatting capabilities. The app provides an interactive UI for adjusting font family, size, and font features (such as calt, clig, kern, liga), and visualizes text layout metrics including extent, baseline, text bounds, run bounds, and hit-test regions. It also exposes detailed information about the shaped buffer (glyphs, codepoints, advances) and character hit data, allowing developers to inspect how text is rendered and measured.

samples/TextTestApp · high confidence

A new Utf8Buffer class has been added to the Avalonia.Platform.Interop namespace to facilitate efficient conversion between .NET strings and native UTF-8 byte buffers. This internal helper uses pinned memory and ArrayPool for reduced allocations when passing string data across interop boundaries, supporting both IntPtr and byte\* implicit conversions for easier integration with native APIs.

src/Avalonia.Base/Platform/Interop · high confidence

Avalonia now includes a new Wayland platform implementation that enables native windowing on Wayland compositors. Users can opt into this backend using the new UseWayland() extension, or enable automatic fallback to X11/other backends if Wayland is unavailable via UseWaylandWithFallback(). The backend provides full clipboard support (copy/paste of text, files, and bitmaps), drag-and-drop functionality, and proper popup positioning and dismissal. It also handles screen scaling, compositor restarts, and cross-thread communication safely.

src/Avalonia.Wayland · high confidence

Added two new sample applications, ControlGallery.WinUI and WinUIEmbedSample, to demonstrate embedding Avalonia content within a native WinUI (Microsoft.UI.Xaml) host. These samples provide a side-by-side UI showing native WinUI controls alongside Avalonia controls rendered via AvaloniaSwapChainPanel, including interactive demos for clipboard, drag-and-drop, and accessibility automation peer probing.

samples/ControlGallery.WinUI, samples/WinUIEmbedSample · high confidence

The \Avalonia.Base/Metadata\ directory now includes a comprehensive set of new attributes to enhance XAML compilation and API management. \XmlnsDefinitionAttribute\ and \XmlnsPrefixAttribute\ allow developers to map XML namespaces to CLR namespaces and define preferred prefixes, improving XAML readability and compatibility. \PrivateApiAttribute\ and \UnstableAttribute\ provide explicit markers for internal or evolving APIs, helping to manage stability guarantees. Additionally, \InheritDataTypeFromAttribute\ and \InheritDataTypeFromItemsAttribute\ offer finer control over data type inheritance in compiled bindings, while \IAddChild\ and \DependsOnAttribute\ support more complex markup parsing and property dependencies.

src/Avalonia.Base/Metadata · high confidence

The RenderDemo sample now includes dedicated view models to support new interactive demonstrations: AnimationSpeedPageViewModel exposes controls for speed ratio, playback direction, and delays; AnimationsPageViewModel adds play/pause toggling; MainWindowViewModel introduces toggles for drawing dirty rects, FPS counters, and layout/render time graphs, along with a window resize animation; and Transform3DPageViewModel provides sliders for 3D depth and rotation angles.

samples/RenderDemo/ViewModels · high confidence

The \src/Avalonia.Base/Animation/Animators\ directory now contains the concrete implementations for the animation system's type-specific animators. This includes the base \Animator\<T\>\ class that handles keyframe interpolation and scheduling, as well as dedicated animators for numeric types (Double, Float, Int32, etc.), geometry types (Point, Rect, Size, Thickness, CornerRadius), and media types (Color, SolidColorBrush, GradientBrush, BoxShadow). Notably, the \GradientBrushAnimator\ and \BaseBrushAnimator\ have been updated to support \TransformOperations\ and \RelativeTransform\ animations, allowing for smoother and more complex brush transformations during animations.

src/Avalonia.Base/Animation/Animators · high confidence

This update introduces several foundational capabilities to the base library. It adds a \Cue\ type and \CueTypeConverter\ to support precise time-indexing for animation keyframes. The binding system is overhauled with a new \BindingValue\<T\>\ struct that explicitly tracks value, error, and fallback states, alongside a \ResourcesChangedEventArgs\ struct to efficiently identify resource changes. Rendering is enhanced with a new \RenderOptions\ record that allows fine-grained control over bitmap interpolation, edge modes, and opacity handling, while also deprecating the old \TextRenderingMode\ in favor of \TextOptions\. Additionally, input handling gains a \VelocityTracker\ for more accurate scroll inertia calculations, and text rendering supports advanced font features via a new \FontFeature\ type and improved Unicode codepoint handling.

Avalonia.Base · high confidence

The imaging subsystem in Avalonia.Base now provides a modernized API for loading, manipulating, and saving bitmaps. Users can save images to specific formats (PNG or JPEG) using dedicated options classes (PngBitmapEncoderOptions, JpegBitmapEncoderOptions) that allow control over compression quality and level, replacing the previous single-format save method. The system also introduces pixel format transcoding, enabling WriteableBitmap to handle non-native pixel formats by automatically converting them to a supported internal format (Rgba8888) during locking and copying operations. Additionally, new classes like CroppedBitmap and RenderTargetBitmap offer more granular control over image cropping and rendering contexts, while new enums like BitmapBlendingMode and BitmapInterpolationMode provide finer control over how images are composited and scaled.

src/Avalonia.Base/Media/Imaging · high confidence

The interactivity layer now supports cancelable routed events via the new CancelRoutedEventArgs class, which includes a Cancel property that allows handlers to stop event propagation. The Interactive base class and its extension methods have been updated to manage these events, including the ability to add disposable handlers and observe events as observables. The EventRoute class handles the routing logic for these events, ensuring that cancellation is respected during the bubbling and tunneling phases.

src/Avalonia.Base/Interactivity · high confidence

The ColorPicker's converter layer now includes several new value converters to improve color handling and binding flexibility. AccentColorConverter generates accent color steps by adjusting the HSV value component, enabling consistent accent color derivation. ColorToHexConverter supports configurable alpha visibility and position (leading or trailing) in hex string output, while ColorToDisplayNameConverter correctly handles fully transparent colors by returning unset instead of a misleading name. ToBrushConverter and ToColorConverter provide robust conversions between Color, HslColor, HsvColor, and SolidColorBrush types, with ToColorConverter accounting for brush opacity when extracting alpha. ContrastBrushConverter selects black or white text based on luminance, with an alpha threshold to fallback to a default color when transparency is high. DoNothingForNullConverter prevents binding updates when null values are encountered, improving stability in nullable binding scenarios.

src/Avalonia.Controls.ColorPicker/Converters · high confidence

The ColorPicker now supports additional color selection options through the introduction of the IColorPalette interface and several new implementations. Users can choose from the FlatColorPalette (a full flat design chart), the FlatHalfColorPalette (a reduced subset for improved usability), the MaterialColorPalette (based on the 2014 Material Design system), the MaterialHalfColorPalette (a reduced Material subset), the FluentColorPalette (standard Windows 10 colors), and the SixteenColorPalette (standard HTML 4.01 colors). These palettes provide diverse styling choices for color selection within the application.

src/Avalonia.Controls.ColorPicker/ColorPalettes · high confidence

This change introduces a new expression language for Avalonia's composition animations, allowing users to define complex animation behaviors using a string-based syntax with support for arithmetic, logical, and relational operators. It includes a parser (\ExpressionParser\) and a Foreign Function Interface (\BuiltInExpressionFfi\) that exposes built-in mathematical functions (such as \Lerp\, \SmoothStep\, \Abs\, \Clamp\), vector and matrix operations, and color interpolation (\ColorLerp\) directly within animation expressions. The implementation provides the core infrastructure (\Expression\, \ExpressionVariant\, \DelegateExpressionFfi\) required to evaluate these expressions at runtime, enabling more dynamic and data-driven visual effects.

src/Avalonia.Base/Rendering/Composition/Expressions · high confidence

This change introduces a new rendering architecture in Avalonia.Base, centered around a composition engine and a dedicated hit-testing system. It adds a new AABB-tree-based hit-testing implementation (CompositionHitTestAabbTree) with specialized testers for points and geometries, replacing or augmenting previous methods. A new render loop (RenderLoop, IRenderLoop) and multiple render timer implementations (DefaultRenderTimer, SleepLoopRenderTimer, ThreadProxyRenderTimer, UiThreadRenderTimer) provide more flexible and precise control over the rendering frame rate and background execution. The update also includes a new ImmediateRenderer for direct visual tree rendering, interfaces for presentation sources (IPresentationSource) and renderers (IRenderer, IHitTester), and support for debug overlays (RendererDebugOverlays) to visualize FPS, dirty rects, and layout/render times.

src/Avalonia.Base/Rendering · high confidence

The \src/Avalonia.Base/Data/Converters\ directory now provides a comprehensive set of built-in value and multi-value converters, along with the core \IValueConverter\ and \IMultiValueConverter\ interfaces. Users can now easily perform common operations using \BoolConverters\ (And, Or, Not), \ObjectConverters\ (IsNull, IsNotNull, Equal, NotEqual, AreAllNull, AreAnyNull, AreAllEqual), and \StringConverters\ (IsNullOrEmpty, IsNotNullOrEmpty). The new \FuncValueConverter\ and \FuncMultiValueConverter\ classes allow for quick, inline conversion logic using lambdas, while \StringFormatValueConverter\ and \StringFormatMultiValueConverter\ enable direct string formatting in bindings. Additionally, \DefaultValueConverter\ handles standard type conversions and method-to-command binding, and \MethodToCommandConverter\ facilitates binding UI commands to methods with support for \CanExecute\ logic and weak property change tracking to prevent memory leaks.

src/Avalonia.Base/Data/Converters · high confidence

This update adds several new value converters to the Avalonia.Controls.Converters namespace to support advanced UI binding scenarios. Users can now use BorderGapMaskConverter to generate visual brushes for GroupBox headers, and CornerRadiusFilterConverter or CornerRadiusToDoubleConverter to manipulate or extract specific corners from CornerRadius values. For layout, TreeViewItemIndentConverter and MarginMultiplierConverter provide dynamic indentation and margin scaling based on depth or scalar values. Additional converters include EnumToBoolConverter for radio button binding, StringFormatConverter for string formatting, MenuScrollingVisibilityConverter for menu scrolling indicators, PlatformKeyGestureConverter for platform-specific key gesture display, and MenuScrollingVisibilityConverter for menu scrolling visibility.

src/Avalonia.Controls/Converters · high confidence

The designer support now includes a new \DesignWindowLoader\ class that handles loading XAML into a preview window for design-time scenarios. This loader supports remote previewing by accepting XAML content, assembly paths, and project paths to construct a fake URI for resource resolution. It respects the \AvaloniaUseCompiledBindingsByDefault\ setting from the loaded assembly and applies design-mode properties to the resulting control. The loader also handles window sizing by automatically setting \SizeToContent\ for width and height if they are not explicitly set, and configures the render scaling for off-screen implementations to support HiDPI previews.

src/Avalonia.DesignerSupport · high confidence

Developers can now inspect the internal state of Avalonia properties and application performance using new diagnostic tools. The \AvaloniaObjectExtensions\ class exposes \GetDiagnostic\ and \GetValueStoreDiagnostic\ methods, allowing you to retrieve detailed information about property values, their binding priorities, and the specific frames (local, style, theme, or template) that set them. Additionally, the \Diagnostic\ class now provides structured metrics and activity tracing for key rendering and layout operations—such as compositor passes, layout measurement, and input handling—enabling precise performance profiling of Avalonia applications.

src/Avalonia.Base/Diagnostics · high confidence

The animation system now includes a comprehensive set of new easing functions—Back, Bounce, Circular, Cubic, Elastic, Exponential, Quadratic, Quartic, Quintic, and Sine (each with In, Out, and InOut variants)—allowing for more varied and realistic motion effects. Additionally, a new SpringEasing class has been added, enabling physics-based animations with configurable mass, stiffness, damping, and initial velocity. The base Easing class now supports parsing these types via string, and a TypeConverter is provided for easier integration in XAML.

src/Avalonia.Base/Animation/Easings · high confidence

The \src/Avalonia.Controls/Templates\ area introduces a suite of new types and extension methods to simplify template creation and inspection. Developers can now use \FuncControlTemplate\, \FuncDataTemplate\, and \FuncTreeDataTemplate\ to define templates via lambda functions instead of XAML or complex classes, with \FuncDataTemplate\ supporting element recycling for performance. A new \DataTemplates\ collection validates that typed templates have their \DataType\ set, and \DataTemplateExtensions.FindDataTemplate\ provides a standardized way to resolve templates by walking the logical tree and checking global templates. Additionally, \TemplateExtensions.GetTemplateDescendants\ allows controls to easily retrieve all visual children that belong to their template, replacing the older \GetTemplateChildren\ method.

src/Avalonia.Controls/Templates · high confidence

Developers can now run Avalonia UI tests using NUnit and xUnit v3 with full support for the Avalonia Dispatcher synchronization context. The diff introduces the \Avalonia.Headless.NUnit\ and \Avalonia.Headless.XUnit\ packages, providing \AvaloniaTest\/\AvaloniaTheory\ and \AvaloniaFact\/\AvaloniaTheory\ attributes respectively. These attributes ensure that asynchronous test code resumes on the correct UI thread, resolving common issues with custom synchronization contexts in headless environments. The implementation includes custom test runners and command wrappers to properly handle setup/teardown and dispatcher job execution within the test lifecycle.

src/Headless · high confidence

The iOS platform backend has been replaced with a new implementation that uses Metal for rendering (with EAGL/OpenGL ES retained as a deprecated fallback for iOS 12 and earlier). This update introduces comprehensive UIAccessibility support via AutomationPeerWrapper, enabling VoiceOver and screen reader compatibility. It also adds a robust clipboard implementation that supports text, files, and images, and introduces an ActivatableLifetime to handle app activation events such as universal links and protocol handlers.

src/iOS · high confidence

The Documents namespace now introduces a new inline-based text model, adding classes such as Inline, Span, Run, Bold, Italic, Underline, and LineBreak to support rich, structured text content. A key addition is InlineUIContainer, which allows embedding arbitrary UI controls directly within flowing text, with proper layout, logical tree, and visual tree management. This change enables complex text layouts where UI elements and text can coexist inline, moving beyond simple string-based text rendering.

src/Avalonia.Controls/Documents · high confidence

This change introduces a new set of types in the \Avalonia.LogicalTree\ namespace to improve logical tree traversal and responsiveness. \ILogical\ and \ILogicalRoot\ define the core node interfaces, while \LogicalExtensions\ provides convenient methods for enumerating ancestors, descendants, and siblings, as well as finding elements by type. \ControlLocator\ offers a reactive way to track specific ancestors relative to a control. Additionally, \IChildIndexProvider\ and \ChildIndexChangedEventArgs\ enable controls to notify subscribers when child indices or total counts change, supporting features like CSS nth-child selectors.

src/Avalonia.Base/LogicalTree · high confidence

The \src/Avalonia.Base/Utilities\ folder now includes several new internal helper types designed to reduce memory allocations and improve performance in collection handling and text processing. \ArrayBuilder\<T\>\ and \ArraySlice\<T\>\ provide allocation-free array building and slicing capabilities, while \FrugalList\<T\>\ offers a storage model optimized for small lists to minimize steady-state memory footprint. Additionally, \CharacterReader\ and associated parsers (\IdentifierParser\, \KeywordParser\) enable efficient, span-based text parsing, and \AvaloniaPropertyDictionary\ provides a specialized, non-enumerable dictionary for property values to enhance lookup performance.

src/Avalonia.Base/Utilities · high confidence

Added a suite of internal classes in the \Avalonia.Media.Fonts.Tables\ namespace to parse specific OpenType font tables (such as \head\, \hhea\, \maxp\, \loca\, and \FeatureList\). These components, including a big-endian binary reader and cycle-detection utilities, provide the foundational data structures required for advanced font processing features like glyph outline retrieval and complex text shaping.

src/Avalonia.Base/Media/Fonts/Tables · high confidence

Added PseudoClassesAttribute and TemplatePartAttribute to the Avalonia.Controls.Metadata namespace. PseudoClassesAttribute allows controls to declare their supported pseudoclass names, enabling better code-completion in IDEs. TemplatePartAttribute defines control template parts referenced by name in code, specifying the part name, expected type, and whether the part is mandatory, which helps style authors identify required elements and their types.

src/Avalonia.Base/Controls/Metadata · high confidence

This change introduces a comprehensive page-based navigation system for Avalonia, adding a new \INavigation\ interface and a suite of page controls to \src/Avalonia.Controls/Page\. Users can now utilize \NavigationPage\ for stack-based navigation, \CarouselPage\ for swipeable carousels, \DrawerPage\ for slide-out menus, and \ContentPage\ for simple content views. The diff also adds supporting infrastructure including \MultiPage\ as a base for multi-child pages, layout behavior enums (\BarLayoutBehavior\, \DrawerLayoutBehavior\), and event argument classes (\NavigatedFromEventArgs\, \ModalPoppedEventArgs\, etc.) to handle navigation lifecycle events.

src/Avalonia.Controls/Page · high confidence

The platform layer introduces a suite of new interfaces to standardize platform-specific capabilities, including IPlatformSettings for system preferences (tap sizes, language, color values), IAssetLoader and a static AssetLoader class for loading application resources, and updated interfaces for rendering (IDrawingContextImpl, IPlatformRenderInterface) and graphics (IPlatformGpu, IExternalObjectsRenderInterfaceContextFeature). These changes provide a more structured and extensible foundation for platform implementations, allowing better separation of concerns and support for advanced features like external GPU memory interop and dynamic asset loading.

src/Avalonia.Base/Platform · high confidence

This change introduces a new set of platform interfaces in the \Avalonia.Controls.Platform\ namespace to standardize and extend system-level interactions. It adds \IMenuInteractionHandler\ and \DefaultMenuInteractionHandler\ to manage keyboard and pointer behavior for menus, including configurable show delays. It introduces \IInsetsManager\ to handle safe area padding, system bar visibility, and edge-to-edge display preferences, along with \IInputPane\ for software keyboard state and bounds. Additionally, it adds \IPlatformFeedback\ for sound and haptic feedback, \ITrayIconImpl\ for system tray icon support, and \IWindowingPlatform\ for window z-order queries, providing a more robust foundation for platform-specific features like native menus, tray icons, and modern window insets.

src/Avalonia.Controls/Platform · high confidence

The file dialog subsystem now exposes new platform interfaces to support more flexible storage handling. Developers can register custom storage providers via the new IStorageProviderFactory, allowing them to replace native implementations with custom logic. Additionally, the system now supports monitoring mounted drives through IMountedVolumeInfoProvider, which forwards updates to an ObservableCollection of MountedVolumeInfo, enabling UI components to react to changes in available storage volumes.

src/Avalonia.Controls/Platform/Dialogs · high confidence

The binding engine now includes new expression nodes in the Reflection namespace to support dynamic property access via plugins, stream handling, and indexer access. DynamicPluginPropertyAccessorNode allows reading properties through registered IPropertyAccessorPlugin instances at runtime, while DynamicPluginStreamNode handles streams via IStreamPlugin. ExpressionTreeIndexerNode and ReflectionIndexerNode enable binding to object indexers using expression trees and reflection respectively, and ReflectionTypeCastNode provides reflection-based type casting within binding paths.

src/Avalonia.Base/Data/Core/ExpressionNodes/Reflection · high confidence

The remote designer previewer now supports multiple display methods via the \--method\ flag: \avalonia-remote\ (default, binary image transfer), \html\ (starts an HTML/WebSocket server for web-based preview), and \win32\ (renders in a native Win32 window). A new \FileWatcherTransport\ allows standalone XAML previewing by polling a file for changes. The previewer windowing platform has been refactored to use a singleton \PreviewerWindowImpl\ with a \DetachableTransportConnection\ to manage message routing, and includes stubs for platform features like storage and screens to ensure stability in design mode.

src/Avalonia.DesignerSupport/Remote · high confidence

Added several new value converters to the ControlCatalog sample application to support specific UI demonstrations. These include DegToRadConverter for angle unit conversion, FlexDemoNumberToThicknessConverter for the Flex Panel demo, GdpToBrushConverter for conditional color mapping, HexConverter for hexadecimal string handling, MathSubtractConverter for arithmetic operations, and TableViewColumnWidthConverter for dynamic column sizing in the TableView demo.

samples/ControlCatalog/Converter · high confidence

The ControlCatalog sample now includes new model classes to support its UI structure and data demonstration capabilities. A \CatalogTheme\ enum defines available visual themes (Fluent, Simple), while \HomeSection\ and \PageItem\ classes manage the navigation hierarchy and search functionality for the catalog's home page. Additionally, new data models \Person\ and \StateData\ have been added to provide sample data for demonstrating validation (\INotifyDataErrorInfo\) and list-based controls.

samples/ControlCatalog/Models · high confidence

The composition rendering system has been refactored to use a new server-side architecture. This introduces a \CompositorDrawingContextProxy\ that batches drawing commands (transforms, clips, opacity, effects) to optimize render performance. New server-side visual types (e.g., \ServerCompositionSolidColorVisual\, \ServerCompositionExperimentalAcrylicVisual\) handle specific rendering tasks. Additionally, a comprehensive diagnostics overlay system has been added, providing real-time FPS counters, memory usage stats, and time graphs for layout, render, and compositor update phases to aid in performance debugging.

src/Avalonia.Base/Rendering/Composition/Server · high confidence

The Shapes namespace now includes a complete set of vector drawing primitives. Users can draw circular arcs (Arc) and pie-shaped sectors (Sector) using start and sweep angles, render basic lines (Line) between two points, and display arbitrary vector data (Path). Standard geometric forms are also available: Ellipse for ovals, Rectangle with optional rounded corners (RadiusX/RadiusY), Polygon for closed multi-point shapes, and Polyline for open multi-point paths. All shapes support standard styling properties like Fill, Stroke, StrokeThickness, and StrokeDashArray, and automatically recalculate their geometry when these properties or their specific defining attributes change.

src/Avalonia.Controls/Shapes · high confidence

The text layout system has been replaced with a new implementation in the TextFormatting namespace. This introduces full bidirectional (BiDi) text reordering via the BidiReorderer, allowing correct display of mixed Left-to-Right and Right-to-Left text. To improve performance and reduce memory pressure, the engine uses FormattingObjectPool and FormattingBufferHelper to reuse temporary lists and arrays during layout. The new system also introduces ShapedBuffer for efficient glyph storage and InterWordJustification for distributing space in justified text.

src/Avalonia.Base/Media/TextFormatting · high confidence

The animation system now includes dedicated transition classes for a wide range of property types, allowing smoother and more precise visual changes. New additions include BoolTransition, BoxShadowsTransition, BrushTransition (with support for gradient and solid color interpolation), ColorTransition, CornerRadiusTransition, DoubleTransition, FloatTransition, IntegerTransition, PointTransition, RelativePointTransition, SizeTransition, ThicknessTransition, TransformOperationsTransition, and VectorTransition. Additionally, Rotate3DTransition has been updated to fix flickering issues during backward navigation.

src/Avalonia.Base/Animation/Transitions · high confidence

Added a suite of utility classes in src/Avalonia.Controls/Utils to support control behavior and rendering. This includes AncestorFinder for observing ancestor changes, BindingEvaluator for evaluating bindings, BorderRenderHelper for optimized border and background rendering with box-shadow support, and ClipboardHelper/PrimarySelectionHelper for clipboard and primary selection management. CollectionChangedEventManager handles collection change notifications with weak event patterns, while RealizedStackElements and VirtualizingSnapPointsList support virtualization in stack panels. Additional utilities include UndoRedoHelper for text editing history, StringUtils for word navigation, and TimeUtils for locale-aware time formatting.

src/Avalonia.Controls/Utils · high confidence

The Render Demo sample now includes two new controls to help visualize rendering behavior. LineBoundsDemoControl demonstrates line bounds calculation by rendering an animated line and its calculated bounding box, while ResizePattern provides a visual grid, diagonals, circles, and edge frame to detect stretching or aspect-ratio issues during window resizing.

samples/RenderDemo/Controls · high confidence

Developers now have access to enhanced tools for querying and observing the visual tree structure. New extension methods in VisualExtensions allow for calculating distances between visuals, finding common ancestors, and locating ancestors or descendants by type with optional predicates. A new TransformedBounds struct provides a convenient way to handle bounds, clips, and transforms together, while the VisualLocator class introduces reactive tracking of ancestor visuals, automatically updating when tree attachment changes.

src/Avalonia.Base/VisualTree · high confidence

The GridSplitter control has been ported from WPF, allowing users to resize rows and columns within a Grid layout by dragging the splitter handle. This adds a standard interactive resizing capability to the Avalonia.Controls library, matching the behavior found in WPF applications.

src/Avalonia.Controls · high confidence

The MainViewModel for the SafeAreaDemo sample now exposes properties and commands to control the on-screen keyboard (InputPane) state, including its rectangle, animation duration, and easing, as well as toggles for safe area padding, edge-to-edge display, and system bar visibility. It also adds explicit methods to set the application theme to Light, Dark, or Default (system), allowing users to test these UI behaviors within the demo.

samples/SafeAreaDemo/ViewModels · high confidence

The UnloadableAssemblyLoadContext sample now includes a complete implementation showing how to load and unload Avalonia content from a collectible AssemblyLoadContext. The sample application loads a plugin assembly containing Avalonia controls and styles, and upon closing, it explicitly unregisters Avalonia properties, removes styles from the application, and invalidates the asset loader cache to ensure the plugin's memory can be reclaimed by the garbage collector.

samples/UnloadableAssemblyLoadContext · high confidence

The Skia rendering backend is now available, providing a new graphics rendering path for Avalonia applications. This implementation includes a full drawing context (\DrawingContextImpl\) that supports advanced features such as GPU acceleration via SkiaSharp, custom effects (blurs and drop shadows), and opacity masks. It also introduces comprehensive geometry handling (including combined and group geometries), optimized text rendering with glyph run caching, and a robust font management system. The backend supports multiple rendering targets, including framebuffer surfaces and custom GPU render sessions, and includes platform-specific optimizations for Metal on macOS.

src/Skia · high confidence

Developers now benefit from a consistent coding style and streamlined project loading. A new .editorconfig enforces formatting rules (indentation, brace placement, naming conventions) and configures the severity of .NET analyzers and Avalonia-specific diagnostics. Additionally, platform-specific solution filters (Avalonia.Android.slnf, Avalonia.Desktop.slnf, Avalonia.iOS.slnf) allow IDEs to load only the relevant subset of projects for the target platform, reducing load times and clutter.

(repo-wide) · high confidence

The styling system now supports container queries, allowing styles to react to the size of a parent container via the new Container, ContainerQuery, and ContainerSizing APIs, alongside control themes (ControlTheme) that enable switchable, type-based theming with inheritance (BasedOn). Additionally, the selector engine has been expanded with new combinators and pseudo-classes including the nesting selector (^), child (\>) and descendant combinators, :not(), :nth-child(), and property equality selectors, providing more granular control over style application.

src/Avalonia.Base/Styling · high confidence

Avalonia.OpenGL now supports importing external GPU memory (specifically via the GL\_EXT\_memory\_object and GL\_EXT\_semaphore extensions) into OpenGL textures. This allows applications to integrate with external graphics APIs, such as importing Vulkan images on Linux via POSIX file descriptors, enabling zero-copy sharing of graphics resources between Avalonia and other rendering systems.

src/Avalonia.OpenGL · high confidence

The GpuInterop sample now includes a new Vulkan-based demo that renders a 3D scene using custom GLSL shaders compiled to SPIR-V. This implementation enables cross-API GPU memory sharing by integrating with DirectX 11 on Windows (via NT shared handles and keyed mutexes) and Metal on macOS (via IOSurface interop), allowing the Vulkan rendering pipeline to present frames directly to the Avalonia composition surface.

samples/GpuInterop/VulkanDemo · high confidence

The Win32 UI Automation implementation has been rewritten to use the .NET \GeneratedComInterface\ and \GeneratedComClass\ attributes, replacing the previous COM interop approach. This change introduces a new \Avalonia.Win32.Automation\ project containing interop interfaces (such as \IExpandCollapseProvider\, \IRangeValueProvider\, \IScrollProvider\, \ISelectionProvider\, \IToggleProvider\, and \IValueProvider\) and a central \AutomationNode\ class that maps Avalonia automation peers to UI Automation providers. For users, this provides a more robust and maintainable foundation for accessibility features on Windows, ensuring that screen readers and other assistive technologies can correctly interact with Avalonia controls.

src/Windows · high confidence

Developers can now access the original file path, line number, and column for XAML elements at runtime via the new XamlSourceInfo API. This enables enhanced debugging and diagnostics by allowing tools and developers to trace UI elements back to their exact definition in the source code.

Markup · high confidence

The ControlCatalog.iOS sample project has been added, providing a native iOS host for the ControlCatalog application. This includes the standard iOS entry point (Main.cs), application delegate (AppDelegate.cs) configured to use the Avalonia iOS backend, and project metadata (Info.plist, Entitlements.plist). The sample also introduces an EmbedSampleIOS component that demonstrates embedding native iOS controls, such as a WKWebView and a UIButton, within the Avalonia UI.

samples/ControlCatalog.iOS · high confidence

The \ContentPresenter\, \Control\, \Decorator\, \TemplatedControl\, and \TextBlock\ classes have been removed from the \Perspex/Controls\ directory. This eliminates the existing logic for layout measurement, content presentation, templating, and text rendering provided by these specific components.

Perspex/Controls · high confidence

The \Perspex.Windows\ assembly has removed its core Windows platform implementation, including the \DrawingContext\, \Renderer\, \Window\, and \Dispatcher\ classes. This deletes the Direct2D/DirectWrite rendering pipeline, the Win32 window creation and message handling (\UnmanagedMethods\), and the threading dispatcher infrastructure that previously powered the Windows backend.

Perspex.Windows · high confidence

The TestApplication's legacy startup files (App.config, Program.cs, and AssemblyInfo.cs) have been removed. This eliminates the hardcoded ServiceLocator registration for ITextService and the manual Window/Dispatcher initialization, indicating the test application is no longer used as a standalone entry point or is being replaced by a different testing/hosting mechanism.

TestApplication · high confidence

The \Perspex/Media\ directory has removed several foundational types: \Color\, \FormattedText\, \Pen\, \SolidColorBrush\, and the \IDrawingContext\ interface. This eliminates the previous low-level drawing API and color representation structures from this location, likely as part of a broader refactoring or migration to a different rendering backend.

Perspex/Media · high confidence

The build infrastructure has been reorganized into a centralized \build/\ directory containing a comprehensive set of MSBuild \.props\ and \.targets\ files. This change introduces a unified configuration layer that standardizes shared properties (versioning, signing, nullable reference types, .NET analyzers), manages platform-specific dependencies (SkiaSharp, HarfBuzzSharp, MicroCOM), and handles platform detection for single-project development workflows. It also updates the test infrastructure to use xUnit v3 and configures trimming/AOT compatibility settings for modern .NET targets.

build · high confidence

The runtime XAML loading capability has been moved from the core \Avalonia.Markup.Xaml\ assembly into a new, standalone package (\Avalonia.Markup.Xaml.Loader\). This change introduces the \AvaloniaRuntimeXamlLoader\ class as the primary entry point for loading XAML at runtime, utilizing the \AvaloniaXamlIlRuntimeCompiler\ to compile XAML into IL using the XamlIl backend. The new package includes specific AST nodes for optimized compilation of types like \GridLength\, \FontFamily\, and arrays, along with diagnostic codes and compiler configuration classes, effectively decoupling the heavy runtime compilation logic from the base markup infrastructure.

src/Markup · high confidence

A new internal PresentationSource class has been introduced to centralize input handling, layout management, and rendering responsibilities that were previously part of TopLevel. This change moves the input root, focus manager, layout manager, and compositing renderer into PresentationSource, allowing the visual tree root concept to be decoupled from the TopLevel abstraction. Users benefit from a more modular architecture where input processing, cursor updates, and layout scaling are managed independently of the top-level window implementation, improving maintainability and enabling more flexible windowing scenarios.

src/Avalonia.Controls/PresentationSource · high confidence

The rendering pipeline in the composition drawing layer has been refactored to use a binary opcode stream for recording and replaying draw operations. This introduces a new \RenderDataStream\ that serializes drawing commands (lines, rectangles, geometry, text, effects, etc.) into a compact byte buffer, replacing previous allocation-heavy approaches. A visitor pattern (\IRenderDataVisitor\) is now used to process this stream for various tasks including replaying to a drawing context, calculating bounds, and performing hit tests. This change also introduces composition-aware resource management via \ICompositionRenderResource\ and \CompositorResourceHelpers\ to handle reference counting and serialization of resources across different compositor instances, ensuring efficient memory usage and correct resource lifecycle management during rendering.

src/Avalonia.Base/Rendering/Composition/Drawing · high confidence

This change introduces several new files in src/Shared to support older .NET targets and enhance input handling. It adds polyfills for C\# language features and .NET APIs not available in .NET Standard 2.0 and earlier, including CallerArgumentExpressionAttribute, IsExternalInit, ModuleInitializerAttribute, Stream.ReadExactly, and string Contains/EndsWith extensions. Additionally, it introduces RawEventGrouping.cs, which provides a dispatch queue and event grouper to aggregate asynchronous raw pointer and touch events, enabling the GetIntermediatePoints API for smoother input tracking.

src/Shared · high confidence

The Android backend has been refactored to use a new, unified initialization flow via the \UseAndroid()\ extension method, which registers the \AndroidPlatform\ subsystem. This change introduces a new \AndroidDispatcherImpl\ that leverages the Android \Looper\ and \MessageQueue\ for scheduling, replacing the previous dispatcher mechanism. Application lifecycle management is now handled by \AvaloniaAndroidApplication\ and \AvaloniaMainActivity\, which integrate with the new \IActivatableLifetime\ feature to manage activity states. Accessibility support has been overhauled with a new \AvaloniaAccessHelper\ that properly manages virtual view IDs and cleans up automation peers when controls leave the visual tree to prevent memory leaks. Additionally, back-press handling on Android 13+ now uses the \OnBackPressedDispatcher\ for correct behavior.

src/Android/Avalonia.Android · high confidence

The Android platform implementation has been reorganized into the new \src/Android/Avalonia.Android/Platform\ directory, introducing dedicated classes for core platform capabilities. This includes \AndroidActivatableLifetime\ for managing activity lifecycle and intent activation, \AndroidInsetsManager\ for handling window insets, safe areas, and edge-to-edge display modes, and \AndroidPlatformSettings\ for retrieving system color values, input configuration, and preferred language. Clipboard functionality is now handled by \ClipboardImpl\ with helper classes for data format conversion, while \AndroidLauncher\ manages URI and file launching. Additional services include \AndroidScreens\ for multi-display support, \AndroidSystemNavigationManager\ for back navigation, \AndroidNativeControlHostImpl\ for embedding native views, and \AndroidPlatformFeedback\ for sound and haptic feedback.

src/Android/Avalonia.Android/Platform · high confidence

The AutoCompleteBox control has been restructured into multiple source files (Properties, main class, enums, and event args) to improve maintainability. This change introduces a comprehensive AutoCompleteFilterMode enum allowing users to select from culture-sensitive, case-sensitive, ordinal, and custom filtering strategies (StartsWith, Contains, Equals). It also adds new StyledProperties for CaretIndex, PlaceholderText (replacing the obsolete Watermark), PlaceholderForeground, and ClearSelectionOnLostFocus, while exposing Populating and Populated events via dedicated event argument classes to allow users to cancel or inspect filtering operations.

src/Avalonia.Controls/AutoCompleteBox · high confidence

The macOS native backend now automatically builds the \libAvalonia.Native.OSX.dylib\ during the build process via a new \Avalonia.Native.macOS.proj\ project, eliminating the need for manual Xcode builds. This change is accompanied by a new \generate-headers.sh\ script to simplify header generation and a \README.md\ that enforces the use of smart COM pointers (\ComPtr\, \ComObjectWeakPtr\, \ComStaticPtr\) instead of raw pointers to prevent memory leaks and lifetime issues.

native/Avalonia.Native · high confidence

The Avalonia MSBuild integration has been reorganized into a new set of props and targets files (Avalonia.props, Avalonia.targets, AvaloniaBuildTasks.targets, etc.) that centralize build configuration. Compiled bindings are now enabled by default (AvaloniaUseCompiledBindingsByDefault=true), and the XAML compiler automatically includes the application icon as the default window icon. The SDK introduces a single-project mode (AvaloniaSingleProject) that allows managing platform-specific code (Android, iOS, Windows, etc.) within a single project structure, similar to .NET MAUI. Additionally, it adds a project property page for Visual Studio, exposes XAML files as Roslyn AdditionalFiles for source generators, and enforces a warning/error when unstable private APIs are used in packable NuGet packages.

packages/Avalonia · high confidence

The Avalonia name source generator now respects a new build property, \AvaloniaNameGeneratorAttachDevTools\, allowing users to disable the automatic attachment of DevTools references during code generation. This change is implemented in the \GeneratorOptions\ class and the \AvaloniaNameIncrementalGenerator\, which checks for the presence of the \Avalonia.Diagnostics\ assembly and conditionally includes it based on this new setting, providing finer control over generated dependencies.

tools · high confidence

The binding expression parser in Avalonia.Base has been rewritten to use a new grammar-based parser (BindingExpressionGrammar) and a dedicated visitor (BindingExpressionVisitor) for compiled bindings. This change introduces a new ArgumentListParser for handling indexer arguments and restructures how binding paths are constructed from both string expressions and LINQ expressions, supporting features like null-conditional operators, type casting, and stream bindings within a more robust parsing framework.

src/Avalonia.Base/Data/Core/Parsers · high confidence

The binding engine in Avalonia.Base has been restructured to use a modular plugin system, replacing the previous monolithic implementation. This change introduces a registry of pluggable components for property access (supporting AvaloniaProperties, INPC, and reflection-based methods), data validation (supporting INotifyDataErrorInfo, DataAnnotations, and exception-based validation), and stream bindings (supporting IObservable and Task). This architecture allows for more flexible binding behaviors and improves compatibility with AOT/trimming scenarios by isolating reflection-heavy logic within specific plugins.

src/Avalonia.Base/Data/Core/Plugins · high confidence

The data binding engine in Avalonia.Base has been restructured to use a new set of core classes for managing binding expressions. This includes the introduction of \BindingExpression\ for untyped bindings, \TypedBindingExpression\ for strongly-typed, unboxed bindings (which improves performance for simple DataContext bindings), and \MultiBindingExpression\ to support binding to multiple sources. The refactor also adds \ClrPropertyInfo\ and \IPropertyInfo\ interfaces to abstract property access, \TargetTypeConverter\ to handle type conversions more robustly, and \StreamBindingExtensions\ to support binding to \Task\ and \IObservable\ sources. These changes provide a more modular and performant foundation for the binding system, enabling features like typed bindings and multi-binding while maintaining backward compatibility with existing binding syntax.

src/Avalonia.Base/Data/Core · high confidence

The BindingDemo sample has been completely rewritten to demonstrate current Avalonia capabilities. It now uses the FluentTheme for its visual style and showcases modern binding features including compiled bindings (e.g., {CompiledBinding}), data validation (DataAnnotations, INotifyDataErrorInfo), and generic markup extensions. The UI has been restructured into tabs covering basic, collection, and advanced binding scenarios, providing a clearer, up-to-date reference for users.

samples/BindingDemo · high confidence

The BindingDemo sample application has been refactored to replace ReactiveUI with the MiniMvvm framework, introducing a new set of view models to demonstrate various binding and validation scenarios. The sample now includes DataAnnotationsErrorViewModel for attribute-based validation, ExceptionErrorViewModel for exception-throwing setters, and IndeiErrorViewModel for INotifyDataErrorInfo support. MainWindowViewModel has been updated to use SelectionModel for item selection and exposes these new validation models, while the legacy ServiceLocator has been replaced by NestedCommandViewModel to better illustrate nested command usage.

samples/BindingDemo/ViewModels · high confidence

The CalendarDatePicker control has been reorganized into its own directory with separated property and event-argument files, introducing a more robust architecture. Users can now benefit from improved text input handling via the new CustomDateFormatString property, which allows for flexible date parsing formats. Additionally, the control now exposes a DateValidationError event, enabling applications to handle invalid user input gracefully rather than crashing, and supports week number visibility in the calendar dropdown.

src/Avalonia.Controls/CalendarDatePicker · high confidence

The clipboard system has been restructured to support persistent content after the application closes (via a new FlushAsync method and in-process data tracking) and to enable reading and copying images. A new ClipboardType enum and platform manager allow access to the primary selection on X11. Additionally, the PlatformHotkeyConfiguration now includes PageUp, PageDown, PageLeft, and PageRight key gestures, and KeyGesture formatting is now platform-aware via KeyGestureFormatInfo.

src/Avalonia.Base/Input/Platform · high confidence

The input subsystem's clipboard and drag-and-drop capabilities have been reworked to use a new, type-safe \DataFormat\ system (replacing the obsolete \DataFormats\ and \DataObject\ classes). This change introduces \DataFormat\ enums for universal (Text, File, Bitmap), application-specific, platform-specific, and in-process data, along with \DataTransfer\ and \DataTransferItem\ implementations that support both synchronous and asynchronous data retrieval. Extension methods (\TryGetText\, \TryGetFileAsync\, etc.) are now provided for easier data access, and the \AccessKeyHandler\ has been updated to improve access key handling logic.

src/Avalonia.Base/Input · high confidence

The color picker helper logic has been reorganized into a dedicated directory and updated to improve color representation and performance. The \ColorHelper.ToDisplayName\ method now uses an HSV-based algorithm that considers all color components to find the closest known color name, replacing the previous hue-only approach. Additionally, the \ColorPickerHelpers.CreateComponentBitmapAsync\ method now supports a perceptive rendering mode that adjusts saturation and value to ensure color gradients remain distinct and discernible to the user. New lightweight structs (\Hsv\, \Rgb\) have been introduced to optimize internal color calculations by removing unnecessary alpha handling and bounds checks.

src/Avalonia.Controls.ColorPicker/Helpers · high confidence

The ColorSlider control has been enhanced to allow users to switch between RGB and HSV color models via the new ColorModel property, with corresponding TwoWay bindings for both Color and HsvColor to ensure precision. A new IsPerceptive property has been added to improve visual usability by forcing saturation and value components to maximum during rendering in HSV mode (or minimizing other components in RGB mode), ensuring gradients remain visible and distinct. Additionally, the control now features an IsAlphaVisible property to control alpha channel rendering, IsRoundingEnabled for cleaner HSV value display, and automatic pseudo-class updates for better contrast in dark/light themes.

src/Avalonia.Controls.ColorPicker/ColorSlider · high confidence

The ColorSpectrum control now includes a ColorSpectrumAutomationPeer, enabling screen readers and accessibility tools to interact with the color selection interface. The control exposes new properties to customize its appearance and behavior, including the ability to select between Box or Ring shapes, configure which HSV color components are displayed, and adjust the minimum and maximum ranges for Hue, Saturation, and Value. Additionally, the selected color is now displayed in a tooltip on the selection indicator, and the control supports dark/light selector visual states for better theme integration.

src/Avalonia.Controls.ColorPicker/ColorSpectrum · high confidence

The assembly metadata now registers multiple Avalonia namespaces (including Controls, Presenters, Primitives, Shapes, Templates, Notifications, Chrome, Documents, Embedding, and Automation) under the URI https://github.com/avaloniaui. This enables XAML consumers to reference these control libraries using a single, consistent XML namespace declaration.

src/Avalonia.Controls/Properties · high confidence

The ControlCatalog sample's view models have been completely rewritten to support the new Page system, replacing the previous navigation model with a structured, sectioned home page and explicit page items. The main window view model now exposes properties for window customizations (such as title bar decorations, minimize/maximize controls, and client area extension) and manages navigation via an INavigation interface. New view models have been added to demonstrate specific controls and features, including Flex layout, ComboBox selection wrapping, ListBox with SelectionModel, context menus, data validation, notifications, platform settings, and split view configurations, all utilizing the MiniMvvm library for command and property change handling.

samples/ControlCatalog/ViewModels · high confidence

The ControlCatalog sample application has been updated to use the new ContentPage-based navigation system, replacing the previous layout structure. This change introduces a standardized page header and theme support across all sample views, such as the new Accelerator, Acrylic, and Adorner Layer pages, providing a consistent and modernized user interface for exploring Avalonia controls.

samples/ControlCatalog/Pages · high confidence

The ControlCatalog sample application has been significantly redesigned to feature a modern, adaptive home page with a sidebar drawer, card-based navigation, and theme switching between Fluent and Simple styles. This change introduces new internal controls (HomeItemExpander, SectionControl, SelectableButton) and a comprehensive resource dictionary (CustomThemes.xaml) to support the new look and feel, while also integrating native system features like macOS dock menus and Windows tray icons directly into the application shell.

samples/ControlCatalog · high confidence

The ControlCatalog.MacCatalyst and ControlCatalog.tvOS sample applications now ship with dedicated Entitlements.plist and Info.plist files. These additions provide explicit configuration for bundle identifiers, display names, supported interface orientations, and device capabilities (such as arm64 requirements), ensuring the samples are correctly configured for their respective Apple platforms.

samples/ControlCatalog.MacCatalyst, samples/ControlCatalog.tvOS · high confidence

The ControlCatalog.Browser sample has been updated to target .NET 8, introducing a new \Program.cs\ that uses the asynchronous \StartBrowserAppAsync\ entry point and supports configuring rendering modes and file dialog polyfills via URL query parameters. A new \EmbedSample.Browser.cs\ file demonstrates embedding Avalonia controls within an iframe and interacting with external JavaScript via \JSImport\. The sample also includes a \runtimeconfig.template.json\ to configure the WASM host, laying the groundwork for running multiple AvaloniaView instances in the browser.

samples/ControlCatalog.Browser · high confidence

The D3D11 demo in the GpuInterop sample has been rewritten to use Silk.NET for Direct3D 11 and DXGI bindings, replacing the previous implementation. This change introduces new files (D3D11DemoControl.cs, D3D11Swapchain.cs, D3DContent.cs, and MiniCube.fx) that handle D3D11 device creation, swapchain management with keyed mutexes for safe image import, and shader compilation/rendering of a rotating cube, enabling users to see how external GPU memory is interoped with Avalonia's composition system using the Silk.NET library.

samples/GpuInterop/D3DDemo · high confidence

The desktop platform detection logic in Avalonia.Desktop now explicitly selects the X11 backend for Linux systems by default. This change is implemented in the new AppBuilderDesktopExtensions.cs file, which centralizes the loading of platform-specific components (Win32, Avalonia Native, X11, Skia, HarfBuzz) based on the operating system, ensuring that Linux applications utilize the X11 rendering backend.

src/Avalonia.Desktop · high confidence

The dispatcher now prevents the .NET runtime from flowing \CultureInfo\ through the execution context, ensuring that UI operations always run under the live culture of the UI thread rather than the culture captured when the operation was queued. This fixes issues where user-set localization or culture changes were silently discarded by queued dispatcher tasks, restoring the expected behavior where the application's culture setting persists across all UI updates.

src/Avalonia.Base/Threading · high confidence

The gesture recognition infrastructure has been restructured by replacing the previous IGestureRecognizer interface with a new abstract GestureRecognizer base class, which now inherits from StyledElement and manages pointer event routing through a dedicated GestureRecognizerCollection. This change introduces improved pinch gesture support that reports rotation angles in degrees and ensures gestures are properly captured to prevent conflicts. Additionally, the swipe gesture recognizer now supports mouse input via a new IsMouseEnabled property and uses a configurable Threshold for detection sensitivity, while the scroll gesture recognizer has been updated to use the root visual for offset calculations and includes a VelocityTracker for more accurate inertia handling.

src/Avalonia.Base/Input/GestureRecognizers · high confidence

The build process for the HTML/WebSocket previewer transport has been replaced with esbuild and Bun, removing the previous webpack dependency. This change introduces a new build configuration (build.js) and TypeScript setup (tsconfig.json) that compiles the previewer assets using esbuild with tree-shaking, minification, and gzip compression, while the dependency lock file (bun.lock) reflects the new toolchain and React/MobX runtime versions.

src/Avalonia.DesignerSupport/Remote/HtmlTransport/webapp · high confidence

The IScrollable interface, which defines properties for scroll extent, offset, viewport, and scroll capabilities, has been relocated to the Avalonia.Base namespace. This change consolidates the core scrolling contract within the base library, ensuring that controls implementing this interface are defined in the foundational assembly rather than a more specific or internal location.

src/Avalonia.Base/Controls/Primitives · high confidence

The font matching system now uses BCP-47 culture identifiers to disambiguate regional variants for scripts like CJK (Simplified vs. Traditional Chinese, Japanese, Korean) and others (Cyrillic, Arabic, etc.). This ensures that text renders with the correct regional font variant based on the user's culture setting, rather than falling back to a generic script match.

src/Avalonia.Base/Media/Fonts · high confidence

The font rendering engine now uses a dedicated NameTable implementation to parse the OpenType 'name' table, introducing more robust handling of font metadata. This change ensures that malformed or corrupt name records degrade gracefully to empty values rather than throwing exceptions that would prevent a font from loading. It also implements a specific fallback hierarchy for retrieving font names (prioritizing the requested culture, then US English, then Windows platform defaults, and finally the first available record), which improves consistency in how font family and subfamily names are displayed across different locales.

src/Avalonia.Base/Media/Fonts/Tables/Name · high confidence

The IntegrationTestApp has been completely rewritten to use a page-based navigation system, replacing the previous flat structure with a MainWindow that hosts a ListBox for page selection and a content area for dynamic page loading. This new layout includes dedicated pages for testing various controls (Button, CheckBox, ComboBox, etc.), accessibility features (AutomationPage), and desktop integration (TrayIcon, DockMenu). Additionally, the app now includes an Embedding page that demonstrates native control embedding on Windows (Win32 EDIT control) and macOS (NSTextView), allowing integration tests to verify native control interaction and pointer events within the Avalonia host.

samples/IntegrationTestApp · high confidence

The TileBrushCalculator utility class has been made internal and its implementation simplified to reduce complexity in how tile brushes are rendered. This change affects the internal mechanics of how Avalonia calculates scaling, translation, and intermediate image requirements for tiled brushes, but does not alter the visual output or public API for users.

src/Avalonia.Base/Rendering/Utilities · medium confidence

The browser backend has been refactored into a new \Avalonia.Browser\ namespace, replacing the previous WASM implementation. This change introduces a new \BrowserAppBuilder\ with \StartBrowserAppAsync\ and \SetupBrowserAppAsync\ methods to initialize the application, along with a new \AvaloniaView\ control for rendering content in a specified HTML element. The update brings support for multi-threading via a managed dispatcher loop, configurable rendering modes (WebGL2, WebGL1, Software2D), and a service worker for file picker fallbacks. It also implements modern platform features including clipboard access with permission checks, drag-and-drop handling, screen management, safe area insets, and native control hosting.

src/Browser · high confidence

The \src/Avalonia.Base/Input/Raw\ directory now contains the foundational types for the raw input pipeline, including \RawInputEventArgs\ and its specific derivatives (\RawPointerEventArgs\, \RawKeyEventArgs\, \RawDragEvent\, etc.), along with the \IDragDropDevice\ interface. These classes, marked with \\[PrivateApi\]\, represent the low-level events passed from the windowing subsystem to the \InputManager\ for pre-processing before being converted into standard Avalonia events. This change establishes the internal data structures for handling pointer, key, text, touch, and drag-and-drop inputs at the platform abstraction layer.

src/Avalonia.Base/Input/Raw · high confidence

The layout engine in Avalonia.Base has been restructured to improve performance and reliability. The core \LayoutManager\ now enforces a strict measure-then-arrange sequence and includes a dedicated pass to process 'bring-into-view' requests, ensuring controls are scrolled into view after layout stabilizes. To prevent infinite loops, the system now caps layout passes at 10 and validates all dimension and thickness properties to block NaN or infinite values. Additionally, the layout subsystem now exposes \EffectiveViewportChanged\ events and provides \LayoutInformation\ helpers to query previous measure constraints and arrange bounds.

src/Avalonia.Base/Layout · high confidence

The \src/Avalonia.Controls/Presenters\ directory has been completely rewritten with new implementations for core layout and text components. \ContentPresenter\ now supports a richer set of styling properties (including \BoxShadow\, \BackgroundSizing\, and text properties like \LetterSpacing\ and \MaxLines\) and introduces a \:empty\ pseudo-class for styling when content is absent. \TextPresenter\ has been re-architected to use a new \TextLayout\ and \TextRunCache\ system, adding support for IME preedit text, configurable caret blinking, and improved text selection handling. Additionally, new \TableView\-specific presenters (\TableViewCellsPresenter\, \TableViewColumnHeadersPresenter\, and \TableViewLayoutHelper\) have been added to handle column width calculation and cell layout for the new \TableView\ control, while \ItemsPresenter\ and \ScrollContentPresenter\ have been updated to support logical scrolling and scroll anchoring.

src/Avalonia.Controls/Presenters · high confidence

The data binding engine in Avalonia.Base has been significantly refactored to improve performance, reliability, and developer experience. A new CompiledBinding class allows for reflection-free, AOT-compatible bindings created from lambda expressions, offering better performance than the existing ReflectionBinding. The system now introduces MultiBinding to aggregate values from multiple sources and an AssignBindingAttribute to explicitly control whether a binding is assigned or bound to a property. Binding errors and validation are now surfaced through a unified BindingNotification type, providing detailed error context and supporting nested notifications. Additionally, the binding priority system has been refined (e.g., renaming TemplatedParent to Template), and diagnostic messages for broken bindings have been improved to aid in debugging.

src/Avalonia.Base/Data · high confidence

The project's build infrastructure has been replaced with Nuke, introducing a new set of C\#-based build scripts in the nukebuild directory. This change introduces automated API compatibility validation (ApiDiff) to detect breaking changes, generates CycloneDX Software Bill of Materials (SBOM) for published NuGet packages, and adds specific targets for compiling native libraries on macOS and patching build tasks within packages. The new system also standardizes build parameters, integrates with GitHub Actions and Azure Pipelines, and enforces consistent code formatting via an .editorconfig file.

nukebuild · high confidence

NCrunch project configurations have been migrated from a centralized setup to individual \.ncrunchproject\ files (v3 format) within the \.ncrunch\ directory. This change allows for granular control over build settings per project, such as setting \TargetFramework\ to \netstandard2.0\ for analyzers and generators, or \net10.0-android36.0\ for Android projects. It also explicitly ignores non-testable components (like demos and native platforms) and includes specific additional files, such as \InvariantResources.xaml\, to ensure correct compilation and testing behavior.

.ncrunch · high confidence

This change introduces a new input handling architecture for Android, replacing the previous implementation with dedicated classes in \src/Android/Avalonia.Android/Platform/Input\. It adds \AndroidInputMethod\ to manage the \InputMethodManager\ and soft keyboard lifecycle, \AvaloniaInputConnection\ to bridge Android IME events to Avalonia, and a \TextEditBuffer\ with an \EditCommand\ queue to handle text composition, selection, and batch edits more robustly. Additionally, \AndroidKeyboardDevice\ provides a comprehensive mapping of Android hardware keycodes to Avalonia keys, ensuring better support for physical keyboards and media keys.

src/Android/Avalonia.Android/Platform/Input · high confidence

The OpenGL surface layer now exposes three new interfaces: IGlPlatformSurface, IGlPlatformSurfaceRenderTarget, and IGlPlatformSurfaceRenderingSession. These define the contract for creating OpenGL render targets, initiating draw operations via BeginDraw, and accessing rendering context details such as size, scaling, and Y-flip state during a session.

src/Avalonia.OpenGL/Surfaces · high confidence

The Android platform now uses a new Skia-based rendering pipeline (AndroidFramebuffer, FramebufferManager, InvalidationAwareSurfaceView) that replaces the legacy renderer. This change introduces proper separation of render scaling from desktop scaling, supports both RGB565 and RGBA8888 pixel formats with correct alpha handling, and manages native ANativeWindow handles more robustly to prevent crashes during surface recreation. Users benefit from more reliable rendering on Android, better support for transparency, and fixed issues with surface lifecycle management.

src/Android/Avalonia.Android/Platform/SkiaPlatform · high confidence

The text formatting engine now uses a new implementation of the Unicode Bidirectional Algorithm (UAX \#9) located in the Unicode namespace. This change introduces reusable \BiDiAlgorithm\ and \BiDiData\ instances designed to reduce memory pressure on the garbage collector by reusing work buffers, which improves performance for text layout operations involving mixed-directional text.

src/Avalonia.Base/Media/TextFormatting/Unicode · high confidence

The browser storage module has been replaced with a new implementation that uses IndexedDB to persist file bookmarks, allowing users to save and reopen access to specific files or folders across sessions. File and folder operations (open, save, create, move, delete) now leverage the native File System Access API via the \native-file-system-adapter\ library, with automatic fallback to polyfills for browsers that do not support the native API. The \StorageProvider\ class exposes methods for selecting folders, opening files with type filters, and saving files, while \StorageItem\ handles permission verification and data access, ensuring consistent behavior for reading and writing files in the browser environment.

src/Browser/Avalonia.Browser/webapp/modules/storage · high confidence

The composition rendering system now uses a new byte-stream-based transport mechanism to serialize UI-thread changes for atomic application on the render thread. This change introduces a new \CompositionBatch\ class to manage batch lifecycle and sequence IDs, alongside \BatchStream\ components that serialize data into pooled memory segments for both reference types and blittable structs. The implementation includes platform-specific handling for unaligned memory access (specifically addressing ARM32 JIT bugs) and a memory pool with usage-based reclamation to optimize resource usage during rendering.

src/Avalonia.Base/Rendering/Composition/Transport · high confidence

The popup positioning system has been refactored to use a new \IPopupPositioner\ interface and a managed \ManagedPopupPositioner\ implementation. This introduces granular control over popup placement via \PopupAnchor\, \PopupGravity\, and \PopupPositionerConstraintAdjustment\ (supporting flip, slide, and resize behaviors). Users can now provide a \CustomPopupPlacementCallback\ to define custom positioning logic, and the system automatically handles screen bounds and working areas to ensure popups remain visible.

src/Avalonia.Controls/Primitives/PopupPositioning · high confidence

The NumericUpDown control has been rewritten to use decimal types for its Value, Minimum, Maximum, and Increment properties, replacing the previous double-based implementation. This change introduces new properties for finer control over text display, including NumberFormat, FormatString, TextConverter, and DecimalPlaces, allowing users to customize how numeric values are parsed and presented. The control now supports data validation on the Text and Value properties, ensuring that invalid inputs are properly handled. Additionally, backward compatibility is maintained through obsolete aliases for PlaceholderText (Watermark) and PlaceholderForeground (WatermarkForeground), while new features like InnerLeftContent and InnerRightContent allow for richer template customization.

src/Avalonia.Controls/NumericUpDown · high confidence

The Perspex property system has been overhauled, including renaming the binding method from Bind to SetValue and introducing PerspexProperty.UnsetValue. This change is accompanied by the removal of several legacy core types from the Perspex namespace, specifically PerspexObject, PerspexProperty, PerspexPropertyChangedEventArgs, Point, Rect, Size, and Thickness, as well as the deletion of the original monolithic Perspex library structure.

Perspex · medium confidence

The text input system has been restructured to improve cross-platform IME support and provide finer control over virtual keyboards. A new \TextInputMethodManager\ now coordinates input method clients, utilizing a \TransformTrackingHelper\ to accurately update cursor positions as UI elements move. The \TextInputMethodClient\ interface has been expanded to support preedit text, surrounding text, and context menu actions (Copy, Cut, Paste, Select All). Additionally, developers can now configure keyboard behavior using new attached properties in \TextInputOptions\, including \ContentType\ (e.g., Email, URL, Password), \ReturnKeyType\ (e.g., Done, Search, Go), and text casing options (Lowercase, Uppercase).

src/Avalonia.Base/Input/TextInput · high confidence

The application lifetime system has been restructured to provide more granular control over the application lifecycle. A new \IActivatableLifetime\ interface and \ActivationKind\ enumeration allow applications to detect specific activation events, such as file associations, URI protocols, and background state changes. The \ClassicDesktopStyleApplicationLifetime\ now exposes a \ShutdownRequested\ event that can be cancelled to prevent shutdown, and includes a \TryShutdown\ method for safer programmatic termination. Additionally, startup and exit events now carry dedicated argument classes (\ControlledApplicationLifetimeStartupEventArgs\ and \ControlledApplicationLifetimeExitEventArgs\) to provide better context during these lifecycle transitions.

src/Avalonia.Controls/ApplicationLifetimes · high confidence

The binding engine has been refactored to use a new expression node system located in src/Avalonia.Base/Data/Core/ExpressionNodes. This change introduces specific node types to handle various binding scenarios, including array indexing (ArrayIndexerNode), Avalonia property access (AvaloniaPropertyAccessorNode), collection changes (CollectionNodeBase), and data context resolution (DataContextNode, ParentDataContextNode). It also adds support for logical and visual ancestor lookups (LogicalAncestorElementNode, VisualAncestorElementNode), named element resolution (NamedElementNode), templated parent access (TemplatedParentNode), method-to-command conversion (MethodCommandNode), and stream subscriptions (StreamNode). The core ExpressionNode class now supports null-conditional operator short-circuiting and improved source management, enabling more robust and flexible data binding behaviors.

src/Avalonia.Base/Data/Core/ExpressionNodes · high confidence

The internal platform layer has been restructured to improve resource resolution and memory handling. Assembly resource lookups now use a dedicated resolver that matches assemblies by their manifest module scope name, avoiding culture-specific exceptions during matching. Resource streams are accessed via a new SlicedStream implementation that correctly handles seeking from the end of the stream. Additionally, unmanaged memory allocation on Linux now utilizes mmap instead of standard heap allocation, with explicit disposal checks added in debug builds to detect leaks.

src/Avalonia.Base/Platform/Internal · high confidence

The \src/Avalonia.Base/Controls\ area introduces a new \INameScope\ interface and \NameScope\ implementation that support asynchronous lookups via \FindAsync\, allowing controls to wait for a scope to be fully populated before resolving names. The \ResourceDictionary\ now supports deferred resource loading through \AddDeferred\ and \AddNotSharedDeferred\, and exposes \ThemeDictionaries\ for theme-specific resource resolution. Additionally, \ResourceNodeExtensions\ provide updated \FindResource\ and \TryFindResource\ methods that traverse the logical tree and respect theme variants, while \NameScopeExtensions\ offer typed \Find\<T\>\ and \Get\<T\>\ helpers for locating named elements.

src/Avalonia.Base/Controls · high confidence

The native header files have been restructured to replace raw COM pointers with smart pointer implementations (ComPtr, ComStaticPtr) that automatically manage reference counting, preventing use-after-free errors during COM calls. Additionally, new headers define IOSurface and Metal rendering targets, enabling offscreen rendering on macOS, while a new .gitignore excludes the generated avalonia-native.h file.

native/Avalonia.Native/inc · high confidence

The styling engine's internal activator system has been refactored to use a new \IStyleActivator\ interface and \StyleActivatorBase\ class, replacing the previous implementation. This change introduces dedicated activators for logical operations (\AndActivator\, \OrActivator\, \NotActivator\) and container queries (\ContainerQueryActivatorBase\, \WidthActivator\, \HeightActivator\), along with optimized builders. Crucially, the \NthChildActivator\ has been updated to handle \ChildIndexChanged\ events more robustly, fixing a bug where styles on items in virtualized lists were not applied correctly during index changes.

src/Avalonia.Base/Styling/Activators · high confidence

The ColorPicker assembly now explicitly registers its XAML XML namespaces (https://github.com/avaloniaui) for types in Avalonia.Controls, Avalonia.Controls.Collections, and Avalonia.Controls.Primitives. This allows consumers of the library to use these controls in XAML without needing to manually specify additional assembly references in their markup.

src/Avalonia.Controls.ColorPicker/Properties · high confidence

The \packages/repositories.config\ file has been deleted, removing the centralized configuration that previously pointed to \packages.config\ files for the Perspex.UnitTests, Perspex.Windows, Perspex, and TestApplication projects. This change aligns with the adoption of NuGet package restore, indicating a shift away from the older package management structure.

packages · high confidence

The RenderDemo sample application has been rebuilt to use the FluentTheme for its visual style and a HamburgerMenu control for navigation, replacing the previous layout. The app now includes a comprehensive set of demo pages covering animations, transitions, custom animators, clipping, drawing, hit testing (including geometry hit testing), Skia canvas access, bitmap rendering (RenderTargetBitmap, WriteableBitmap), text rendering (GlyphRun, FormattedText, TextFormatter, LineBounds), path measurement, brushes, and 3D transformations. Additionally, the main window provides a menu to toggle renderer debug overlays such as dirty rects, FPS counters, and layout/render time graphs, and allows users to switch window transparency levels.

samples/RenderDemo · high confidence

Avalonia now uses its own internal reactive implementation in the \Avalonia.Reactive\ namespace, removing the dependency on the external \System.Reactive\ library. This change introduces a suite of lightweight, memory-efficient classes such as \LightweightObservableBase\, \AnonymousObserver\, and \CompositeDisposable\ to handle property change notifications and data binding. By utilizing weak references in observables like \AvaloniaPropertyObservable\ and optimizing observer dispatch with array pooling, the framework significantly reduces memory pressure and prevents memory leaks in data binding scenarios.

src/Avalonia.Base/Reactive · high confidence

The FreeDesktop platform integration has been rewritten to use the xdg-desktop-portal for file pickers and system settings, replacing the previous direct DBus dialogs and GTK-based storage providers. This change introduces a new DBus call queue and helper infrastructure to manage connections more reliably, updates the system tray and menu exporters to use the latest Tmds.DBus.Protocol stack, and adds support for system accent colors and theme variants via the portal API. Users on Linux will now benefit from more consistent file dialog behavior, better handling of parent window handles for portal integration, and improved stability for tray icons and global menus.

src/Avalonia.FreeDesktop · high confidence

The selection behavior for controls like ListBox and ComboBox has been completely rewritten using a new \SelectionModel\ architecture. This change introduces a dedicated \ISelectionModel\ interface and \SelectionModel\<T\>\ implementation that manages selection state independently of the UI, fixing long-standing issues with selection persistence when the source collection changes, crashes during \SelectionChanged\ events, and incorrect event firing order. Users will experience more reliable single and multi-selection, proper handling of value types, and improved performance through batched updates and range-based selection tracking.

src/Avalonia.Controls/Selection · high confidence

The Xcode workspace configuration for the native macOS component has been reorganized. A new workspace data file was added to explicitly reference the project, and an IDE workspace checks plist file was introduced to manage build settings. This change reflects a structural adjustment to how the macOS native project is organized within the Xcode environment.

native/Avalonia.Native/src/OSX/Avalonia.Native.OSX.xcodeproj/project.xcworkspace · medium confidence

The macOS native build project has been reorganized, introducing support for new platform capabilities including per-window menus, drag-and-drop, tray icons, and input method editor (IME) integration. The project now explicitly links against the UniformTypeIdentifiers, IOSurface, and Metal frameworks to support modern macOS features such as UTType handling, offscreen rendering, and hardware-accelerated graphics, while also adding source files for accessibility automation and platform behavior inhibition.

native/Avalonia.Native/src/OSX/Avalonia.Native.OSX.xcodeproj · high confidence

The Android platform backend now features a comprehensive rewrite of input event handling, introducing dedicated helpers for keyboard, motion, and key interoperability. This change enables support for mouse, pen (stylus), and historical touch points, allowing applications to receive more accurate and granular input events. The new implementation maps Android scan codes to physical keys, handles various input device types (keyboard, gamepad, remote), and properly dispatches raw key and text events, improving compatibility with complex input scenarios on Android devices.

src/Android/Avalonia.Android/Platform/Specific · high confidence

The VirtualizationDemo sample has been rewritten to include a Playground page for testing list selection and scrolling behaviors, a Chat page demonstrating virtualized chat messages, and an Expanders page. The demo now uses the FluentTheme, loads sample data from a JSON asset, and displays real-time container realization statistics in the Playground view.

samples/VirtualizationDemo · high confidence

The internal property value storage in Avalonia.Base has been completely refactored to a new architecture in the PropertyStore namespace. This change introduces a frame-based system (ValueFrame) that manages property values by priority (local, style, animation, etc.), replacing the previous implementation. Key user-facing improvements include robust data validation support for styled and direct property bindings, allowing bindings to report errors and invalid states that can be consumed by UI controls. The new store also handles SetCurrentValue correctly, ensuring that programmatically set values are properly overridden and re-evaluated when underlying styles or bindings change. Additionally, performance has been optimized through the use of object pooling for property dictionaries and more efficient value re-evaluation logic.

src/Avalonia.Base/PropertyStore · high confidence

The server-side composition visual now implements its own rendering pipeline, dirty-region tracking, and ancestor transform management. This includes an Ancestor Transform Tracker to correctly position adorners, a multi-version concurrency control readback system for safe UI thread access, and a tree walker that handles transform, clip, and opacity stacks during render and update passes.

src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionVisual · high confidence

The Simple theme has been completely rewritten to use the modern ControlTheme system and ThemeDictionaries, replacing the previous style-based approach. This change introduces proper light and dark mode support via the new Base.xaml resource dictionary, which defines distinct color palettes for each mode. It also standardizes control templates (such as Button, ComboBox, and Calendar) to use the new theming API, ensuring consistent styling and better integration with the framework's theme system.

src/Avalonia.Themes.Simple · high confidence

The SplitView control has been restructured into its own directory, introducing a new SplitViewPanePlacement enum that allows the pane to be positioned on the Top or Bottom in addition to the existing Left and Right options. The control now utilizes routed events (PaneOpening, PaneClosing, PaneOpened, PaneClosed) which support cancellation, replacing previous mechanisms for handling state changes. Additionally, the implementation includes improved light dismiss behavior, fixes for initial state pseudoclass handling, and exposes calculated template settings for layout customization.

src/Avalonia.Controls/SplitView · high confidence

The macOS native backend has been significantly restructured to improve input handling, accessibility, and rendering stability. A new \AvnTextInputMethod\ implementation provides robust support for Input Methods (IME), ensuring correct text composition and cursor positioning. Accessibility (a11y) is enhanced through a dedicated \AvnAutomationNode\ and \AvnAccessibility\ protocol, enabling proper live region announcements, focus management, and property change notifications. Rendering reliability is improved by introducing \PlatformRenderTimer\ (using CVDisplayLink) and \PlatformBehaviorInhibition\ (to prevent App Nap), alongside a new \AutoFitContentView\ for better title bar and blur handling. Additionally, \KeyTransform\ centralizes keyboard scan-code mapping, and \INSWindowHolder\ standardizes access to underlying AppKit objects.

native/Avalonia.Native/src/OSX · high confidence

Comprehensive test suite expansion and stabilization; Removed PerspexObject and PerspexProperty unit tests.

The project now uses a centralized \Directory.Packages.props\ file to manage NuGet package versions across the solution. This change standardizes dependency versions, simplifies updates, and reduces duplication in individual project files by defining versions in a single location.

(dependencies) · high confidence

The local copy of the Rx-Core 2.1.30214.0 NuGet package has been deleted from the repository. This removes the bundled nuspec, XML documentation, and library files for targets including .NET 4.0, .NET 4.5, Windows Phone, and Portable profiles, indicating a shift away from checking in these dependencies directly.

(repo-wide) · high confidence

The Avalonia.DBus and XamlX submodules have been updated to new commits (cada3ecfc1 and d7e37ca respectively). This brings in upstream changes from these external dependencies, which may include bug fixes, performance improvements, or new features provided by the Avalonia.DBus and XamlX projects.

external · high confidence

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

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

• Code Health 55
• Architecture 68
• Maturity 75
• Readiness 55
• Security 59
• Performance 73

• 300 commits — 172 feature/other, 128 fixes

• src/Avalonia.Controls — 68 commits
• src/Avalonia.Base — 60 commits
• src/Android — 17 commits
• native/Avalonia.Native — 15 commits
• src/Windows — 14 commits
• samples/ControlCatalog — 13 commits
• src/Avalonia.X11 — 13 commits
• src/Avalonia.Wayland — 9 commits
• (root) — 8 commits
• src/Avalonia.Themes.Fluent — 8 commits
• tests/Avalonia.Controls.UnitTests — 8 commits
• src/Avalonia.Native — 6 commits
• src/Headless — 6 commits
• samples/IntegrationTestApp — 3 commits
• src/Avalonia.FreeDesktop — 3 commits
• src/Avalonia.OpenGL — 3 commits
• src/Browser — 3 commits
• src/Markup — 3 commits
• tests/Avalonia.Base.UnitTests — 3 commits
• tests/Avalonia.Skia.UnitTests — 3 commits

• fix: Add built-in theme tests and fix several bugs found by them (#22216)
• fix: Android: fix crash on a stale accessibility virtual view id (#22122)
• fix: Compiled Bindings: Fix unpredictable binding to method selection (#21617)
• fix: Control Catalog Pane fixes (#22230)
• fix: Enable IsTrimmable+IsAotCompatible on all sample projects, fix warnings (#21892)
• fix: Fix #7536: crash when changing source during SelectionChanged (#22102)
• fix: Fix - Invalidate image measure when DrawingImage source invalidates (#22028)
• fix: Fix Android crash populating accessibility node for peers that conditionally hide a provider (#21726)
• fix: Fix Android multiline TextBox IME offsets (#21680)
• fix: Fix AssemblyDescriptorResolver.GetAssembly(string name) to not throw CultureNotFoundException (#22137)
• fix: Fix AutoCompleteBox popup not closing on focus lost (#21749)
• fix: Fix AvaloniaView double root creation on Android (#21738)
• fix: Fix BrowserDispatcherImpl never setting _signaled flag (#22093)
• fix: Fix CalendarDatePicker.Focus() not focusing the text box (#22170)
• fix: Fix ClipboardUriListHelper not flushing (#21589)
• fix: Fix ComboBox dropdown not scrolling to selected item when opened (#21764)
• fix: Fix CommandBar secondary visibility during overflow open (#21742)
• fix: Fix DBusPlatformSettings NullReferenceException (#21831)
• fix: Fix DatePicker and TimePicker separator alignment with VerticalContentAlignment (#22023)
• fix: Fix DateTimePickerPanel ItemHeight updates (#22158)
• …and 280 more

• 3 containers · 3 bounded contexts · 2 dependency edges (baseline)

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

AvaloniaUI/Avalonia 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.