XAML in Avalonia

Analogy categoryAnalogies

Avalonia: XAML Beyond Microsoft's Runtime

Avalonia UI is an open-source, community-driven framework that reimplements XAML-style declarative markup and a WPF-inspired API surface on top of its own cross-platform rendering engine (Skia by default), running on Windows, macOS, Linux, and, via mobile targets, iOS and Android. Unlike WPF or UWP, Avalonia does not depend on any Windows-specific runtime component, which is what makes it genuinely cross-platform on Linux desktops such as GNOME and KDE — a platform neither WPF nor classic UWP ever supported. Its XAML dialect deliberately mirrors WPF conventions closely (styles, resource dictionaries, Grid, DataTemplate) specifically to minimize the learning curve for .NET developers already familiar with WPF, though the underlying styling system is closer to CSS with selector-based Style elements than WPF's implicit-type-based styling.

🏏

Cricket analogy: Avalonia is like a franchise T20 league that adopts the ICC's core playing rules but runs its own independent governance outside the traditional boards, similar to Avalonia reimplementing XAML conventions without depending on Microsoft's runtime.

Styling: Selectors Instead of Implicit Types

Where WPF styles typically apply implicitly by TargetType or explicitly by x:Key, Avalonia's Style elements use a CSS-like selector syntax, for example Button.danger targets any Button with the style class danger applied via Classes="danger", and Button:pointerover /template/ ContentPresenter can target a specific part inside a control's template based on pseudo-classes like :pointerover or :pressed. This selector model makes it straightforward to express conditional styling — such as applying a red border only when a TextBox has a validation error — using TextBox:error instead of WPF's more verbose Trigger-based approach nested inside a Style.Triggers block, and it composes more predictably when multiple style classes are combined on one element.

🏏

Cricket analogy: Avalonia's class-based selectors are like a scoring system that applies bonus points based on tagged match conditions — 'day-night' or 'must-win' — rather than a single rigid rule per fixture type, similar to combining multiple style classes predictably on one element.

Compiled Bindings and Cross-Platform Deployment

Avalonia supports both classic reflection-based {Binding} and compiled bindings via {CompiledBinding} (or the x:CompileBindings="True" directive applied at the file or app level), which resolves binding paths against a strongly typed x:DataType at build time, catching typos in property names as compiler errors instead of silent runtime binding failures — directly analogous to UWP and MAUI's x:Bind. Because Avalonia apps compile to a self-contained .NET executable per platform, the same XAML and view-model code can be published as a native Windows .exe, a macOS .app bundle, and a Linux binary (with optional AppImage or Flatpak packaging) from one codebase, which has made it a popular choice for open-source cross-platform tools like the JetBrains Rider-adjacent DevOps tooling ecosystem and various Linux-first .NET desktop utilities.

🏏

Cricket analogy: Compiled bindings catching a typo at build time is like a scorer's software flagging an impossible entry — six byes on a wide — before the scorecard is ever published, rather than letting the error stand uncorrected in the final record.

xml

<!-- Avalonia UserControl using CompiledBinding and class-based selector styling -->
<UserControl xmlns="https://github.com/avaloniaui"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:vm="clr-namespace:App.ViewModels"
             x:Class="App.Views.LoginView"
             x:DataType="vm:LoginViewModel">
    <UserControl.Styles>
        <Style Selector="TextBox.error">
            <Setter Property="BorderBrush" Value="Red" />
            <Setter Property="BorderThickness" Value="2" />
        </Style>
        <Style Selector="Button:pointerover /template/ ContentPresenter">
            <Setter Property="Background" Value="#1565C0" />
        </Style>
    </UserControl.Styles>

    <StackPanel Spacing="8">
        <TextBox Text="{CompiledBinding Username}"
                 Classes.error="{CompiledBinding HasValidationError}" />
        <Button Content="Sign In" Command="{CompiledBinding SignInCommand}" />
    </StackPanel>
</UserControl>

Avalonia's Skia-based rendering means pixel-level visual output is largely consistent across Windows, macOS, and Linux, which is a notable difference from frameworks that delegate rendering to each OS's native widget toolkit.

Not every WPF markup extension or attached property has a direct Avalonia equivalent — for example, WPF's Trigger-heavy Style.Triggers pattern should generally be rewritten using Avalonia's selector-based pseudo-classes rather than ported verbatim, since a literal copy-paste port often will not compile.

Avalonia reimplements XAML and a WPF-inspired API on its own Skia-based renderer, independent of any Microsoft runtime.
It runs natively on Windows, macOS, and Linux desktops, including GNOME and KDE, unlike WPF or classic UWP.
Avalonia styling uses CSS-like selectors and style classes instead of WPF's implicit-TargetType and Trigger model.
Pseudo-classes like :pointerover and :pressed target control states directly in selectors.
CompiledBinding resolves binding paths at build time against a strongly typed x:DataType, catching typos early.
Avalonia apps compile to self-contained native executables per platform from a single shared codebase.
Not all WPF markup extensions or trigger patterns port directly; some require rewriting for Avalonia's selector model.