It’s been 1,007 days since we shipped Avalonia 11.0. In that time, we’ve shipped 54 updates, racked up over 9.3 million NuGet downloads, and watched Avalonia become the dominant cross-platform .NET UI framework. Last year alone, we saw 122 million builds using Avalonia across 2.1 million unique projects. Simply put, Avalonia has become the framework of choice for cross-platform .NET
Today, we’re pleased to share that we’ve released Avalonia 12. We set out to build the best foundational release in Avalonia’s history, and we nailed it.
The Philosophy Behind 12.0
Let me be upfront about what Avalonia 12.0 is, and what it deliberately isn’t.
Avalonia 12 is a deliberate investment in the foundations on which everything else depends. Performance, stability and platform maturity. We’ve focused on the ‘boring’ bits, so that every release after this one ships faster, and we can quickly add a few genuinely exciting new features on top.
We set out to lay the foundations for the next 18 to 24 months of our comprehensive roadmap. Not every major release needs to be a spectacle. Some of the most important work in a framework’s history is the work that makes the next two years of development dramatically easier to deliver. That’s exactly what 12.0 does. With that said, that doesn’t mean we haven’t got some exciting new things to share!
Desktop, Embedded, and Mobile. All First-Class.
Avalonia has earned its reputation as the best cross-platform .NET UI framework for building desktop apps. If you want Windows, macOS, and Linux, it's the obvious choice. But for mobile, the conventional wisdom has always said to look elsewhere. We've been working to change that with 12.0.
With 3x performance improvements on Android, a proper native dispatcher implementation, platform-specific GPU and CPU optimisations, and a complete page-based navigation system designed for mobile interaction patterns, Avalonia 12 is a genuinely competitive option for mobile-first applications. Our time spent developing the Avalonia backend for .NET MAUI has also given us clear visibility into the mobile feature gaps that matter most, and Avalonia 12 closes them. Combined with our partnership with Google's Flutter team to bring the Impeller rendering engine to .NET, the gap between Avalonia and every other cross-platform option in the .NET ecosystem is only getting wider.
Avalonia was built from scratch to render identically everywhere, with a single XAML dialect, a single rendering pipeline, and a single codebase. Our drawn-UI approach isn’t a recent pivot. It’s a decade of refinement, battle-tested across thousands of production applications. 12.0 is the release where we invested everything back into making that foundation faster, more stable, and more capable across every target. Desktop, embedded, and mobile, without compromise.
Performance That Speaks for Itself
In complex visual scenes, Avalonia 12 delivers up to a 1,867% increase in FPS. Nearly twenty times the frame rate. We benchmarked against a scene containing 350,000 unique visual elements. The rendering subsystem improvements that make this possible benefit every Avalonia application, not just extreme scenarios.
But benchmarks only tell part of the story. Here’s what GitHub user LaurentInSeattle had to say after testing the release candidates:
Everything loads noticeably faster. Apps are a bit more ‘snappy’ and reactive. Memory footprint a tad smaller. Apparently, a bit less of Garbage runs. No more ~0.5% CPU (or so) burn when idling. Everything draws noticeably faster. Picking and dragging objects with the mouse is MUCH improved!
Under the hood, the optimisation work is broad. We cache RenderScaling in PresentationSource to avoid repeated lookups. We disable animation processing entirely when a visual isn't visible. We defer default window icon loading until the window is shown. The compositor has been fundamentally reworked, contributing to a 1,867% improvement in rendering throughput. And we enabled compiled bindings by default, so most applications see performance improvements in bindings without changing a line of code. Faster rendering means your applications run on lower-spec hardware, reducing deployment costs. Lower idle CPU means longer battery life. Better binding performance means more responsive UIs without architectural changes.
Upgrade in Hours, Not Days
A Discord user summed up the migration experience after trying preview 1:
Just wanted to shout out that 12.0 preview 1 is working great in my first test. Only had to make a few changes, mostly the data validation change, and then manually patch IconPacks.Avalonia and AvaloniaEdit, but then things just worked.
We were ruthlessly intentional about which breaking changes to accept and which to avoid. Data validation handling moved to the base Control class (a net improvement, but a change you’ll notice), a handful of renames landed for consistency (SystemDecorations became WindowDecorations, for example), and some obsolete APIs were finally removed. But the fundamentals of how you build Avalonia applications haven’t changed.
For enterprise teams, this matters more than any single feature in the release. An upgrade that fits within a sprint, validates against existing test suites, and ships with confidence is what separates a framework you can commit to from one that becomes a liability at every major version boundary.
Android: Three Times Faster
Android performance deserves its own section because the numbers are frankly absurd. Startup time drops from 1,960ms to 460ms with NativeAOT, a 4x improvement. Scrolling jumps from 42 to 120 FPS. Animations hit a locked 60 FPS. And idle CPU usage falls from 0.20 to practically nothing at less than 0.01%, a 20x reduction that means your app stops burning battery the moment it stops moving.
None of this came from a single silver bullet. We implemented a proper IDispatcherImpl for Android using Looper and MessageQueue so threading finally behaves the way the platform expects. We applied targeted optimisations to CPU and GPU utilisation when frame timing falls behind, stripped out unnecessary OpenGL synchronisation calls that were adding latency for zero benefit, and cleaned up surface recreation, safe-area inset padding after resume, and the entire app model around AvaloniaActivity.
The result is that Avalonia on Android is now a genuine production platform for performance-sensitive applications. The gap that previously pushed teams towards framework compromises they shouldn't have had to make? It's closed.
Linux Accessibility: A .NET First
Avalonia 12.0 is the first .NET UI framework to ship a native Linux accessibility backend.
No other .NET framework provides native accessibility support on Linux. We’ve implemented the AT-SPI2 backend, which means Avalonia applications on Linux can now properly interact with screen readers and assistive technologies through the standard infrastructure that the Linux desktop ecosystem relies on.
For organisations deploying to government, healthcare, education, or any regulated environment on Linux, accessibility support is a procurement requirement. Avalonia is now the only .NET framework that can meet it. We’ve also added automation support for validation errors and automation landmarks to controls like HamburgerMenu, extending accessibility beyond screen reader basics into structured navigation.
Navigation Controls: You No Longer Need to Build This Yourself
Avalonia 12.0 ships with a complete page-based navigation system: ContentPage, DrawerPage, CarouselPage, and TabbedPage via TabView, along with the PipsPager control for visual page indicators. Gesture-based navigation with wrap-selection looping works naturally on touch devices. Pages support full template customisation for headers, footers, drawers, and icons.
Every Avalonia team that has built shell-style navigation has had to write and maintain that plumbing themselves. As of 12.0, it ships in the box, with proper lifecycle management, focus handling across page transitions, and full integration with the new themeable decorations system. Build your product, not your navigation stack.
WebView Goes Open Source
When we launched Avalonia Accelerate, the WebView component was part of the commercial offering. For 12.0, we’ve open-sourced it entirely.
This is a strategic decision. WebView locked behind a paywall creates friction at the evaluation stage, exactly the moment you want zero resistance. Removing that barrier means more teams complete their evaluation, more projects reach production, and the ecosystem grows faster. Avalonia WebView uses native platform web rendering: no Chromium bundling, dramatically smaller application sizes, and performance that matches what the OS provides natively.
Wayland: The Groundwork Is Laid
We’ve done the foundational work to support Wayland, and it’s ready for testing. Rather than shipping it to everyone on day one and discovering edge cases in production, we want to partner with a handful of users who have a genuine need for Wayland and run a focused private preview.
If your team is deploying Avalonia applications on modern Linux distributions where Wayland is the default compositor, get in touch. We’re looking for partners to validate the implementation against real-world use cases before general availability.
Themeable Client Window Decorations
Avalonia 12.0 introduces themeable client-side window decorations, with a forced client-side decoration mode that doesn’t require app opt-in. Style your window title bars, expose allowed title bar button actions from the platform, and create a customised windowing experience that still respects native conventions on every target.
The Dispatcher Improvements
Avalonia 12.0 introduces Dispatcher.CurrentDispatcher, Dispatcher.FromThread, and AvaloniaObject.Dispatcher, bringing the threading model closer to what WPF developers expect while being genuinely cross-platform. We’ve added Dispatcher.Yield and Dispatcher.Resume for fine-grained message processing control, explicit background processing support, and proper ExecutionContext capture for Dispatcher.InvokeAsync.
Focus Management, Reimagined
Avalonia 12.0 overhauls focus management comprehensively. You can now cancel focus changes before they happen, the new focus traversal API gives full control over keyboard navigation order, and FocusManager is properly opened for consumers. We’ve also fixed a cluster of long-standing bugs: core GotFocus and LostFocus handling can no longer be skipped, touch and pen focus changes are properly delayed until release, and FocusManager.FocusedElement reports correctly when focus is cancelled or redirected.
Platform Improvements
Mac Catalyst is now enabled in Avalonia.iOS, with the iOS scene delegate implemented for modern app lifecycle management. On macOS, a new NativeDock.Menu API lets you put menu items on the dock icon, Metal rendering cleanup is fixed, and accessibility roles are corrected. On Windows, we’ve prevented DXGI from intercepting Alt+Enter and PrintScreen, and added a WinForms message filter for better interop with hybrid applications.
A Leaner Codebase
Technical debt is business risk. Avalonia 12.0 takes that seriously.
We’ve targeted .NET 10 and SkiaSharp 3.0. We’ve removed netstandard2.0 from almost all projects, dropped Direct2D1, removed Tizen support, removed Avalonia.Browser.Blazor, and deleted BinaryFormatter usage entirely for security hardening. We’ve enabled warnings as errors, onboarded to Central Package Management, enabled nullability annotations across the test suite and native layer, and switched JS builds from Node.js to standalone Bun.
We’ve merged redundant internal interfaces, removed unused classes and methods, and made internal-only types properly non-public. A smaller, cleaner codebase means fewer bugs, faster builds, easier contributions, and lower ongoing maintenance cost for everyone building on Avalonia.
Hundreds of Bug Fixes
This release includes hundreds of individual bug fixes across every platform and subsystem. Virtualisation edge cases in ListBox and ItemsControl. Metal rendering cleanup on macOS. Clipboard handling with X11 INCR transfers on Linux. Android surface recreation and storage queries. iOS input handling. Font weight and stretch matching. RTL content mirroring. Memory leaks in menus.
Every one of these is a production issue that someone won’t hit. A regression that won’t reach your users. A support ticket that won’t be filed. Reliability translates directly to reduced operational risk and fewer late-night incidents.
A Bigger Team, a Faster Engine
When we shipped Avalonia 11.0, we were a much smaller operation. Thanks to the three-year sponsorship from Devolutions combined with growing product revenue, we’ve more than doubled in size. Today, 19 people work at Avalonia UI.
A larger team means we can pursue deep foundational work and visible feature delivery simultaneously. The AT-SPI2 accessibility backend, the threading model overhaul, the rendering pipeline optimisations: these are multi-month investments that demand sustained focus. A team of our current size can pursue them without starving the feature roadmap or slowing down bug fixes. When we tell you what’s coming next, we have the engineering capacity to deliver it.
Documentation: Overhauled
The Avalonia documentation has more than doubled in size, with 125% more guides covering everything from getting started to advanced platform-specific scenarios. We’ve built an AI-powered chat directly into the docs for context-aware answers, added an interactive XAML previewer for experimenting with controls in the browser, and restructured the site for faster navigation and clearer learning paths. If you tried our docs a year ago and found gaps, come back.
What Comes Next
Avalonia 12.0 is deliberately a foundation release. The performance work, the platform maturity, the API cleanup, the navigation system, the accessibility infrastructure: all of it positions us for what’s coming over the next 18 to 24 months. We have ambitious plans for rendering, for tooling, and for platform coverage, and 12.0 gives us the base to execute on them.
More on the roadmap in the coming months. For now, upgrade, test, and let us know how it goes.
Get Started
Avalonia 12.0 is available now on NuGet. Update your package references, build, and ship. If you’re new to Avalonia, install the .NET templates and build a high-performance, visually consistent application for Windows, macOS, Linux, iOS, Android, and WebAssembly, all from a single codebase.
We’re also using today’s release as an opportunity to rethink the Avalonia Accelerate brand and how our commercial products fit into the broader ecosystem. Read about the changes here.
122 million builds. 2.1 million projects. The first .NET framework with native Linux accessibility. The fastest cross-platform rendering engine in the ecosystem. Desktop, embedded, and mobile, all first-class. A migration path measured in hours. Avalonia isn’t becoming the standard for cross-platform .NET. It already is.
Thank you to every contributor, every bug reporter, and every community member who tested the previews and release candidates.