Avalonia Architecture

At the highest level, avalonia is split up into a "core" and two "subsystems".

  • The core is a set of Portable Class Libraries that can run anywhere.
  • The Windowing subsystem is responsible for creating windows, handling input and scheduling timers.
  • The Rendering subsystem is responsible for drawing.

There are currently two Windowing and two Rendering subsystems:

Windowing Subsystems

  • Avalonia.Win32 uses the Win32 API (this also works on 64-bit windows).
  • Avalonia.Gtk uses the GTK2 toolkit and can be run on both Windows and *nix.

Rendering Subsystems

  • Avalonia.Direct2D1 uses Microsoft's Direct2D1 API.
  • Avalonia.Cairo uses Cairo for rendering and Pango for text layout.


The Avalonia core is split up into several assemblies. Note that they're not separated like this because you will want to use them separately; they are separate to maintain separation of concerns and a layered architecture. It is fully possible that they will be ILMerged into a single assembly for distribution.

The assemblies are as follows, from lowest to highest level:


The main classes in this assembly are AvaloniaObject and AvaloniaProperty.

These are Avalonia's versions of XAML's DependencyObject and DependencyProperty. It also defines a AvaloniaDispatcher which is - surprise - our version of XAML's Dispatcher.


The main class in the assembly is Animatable.

Allows AvaloniaProperties to be animated and provides various utilities related to animation.


The main class in this assembly is Visual and its interface IVisual.

Defines the "Visual" layer which is a 2D scene graph, with each node being a IVisual/Visual. Also defines primitives such as Point/Rect/Matrix, plus Geometry, Bitmap, Brush and whatever else you might need in order to draw to the screen.


The main interface in this assembly is IStyleable.

Defines a CSS-like system for styling controls.


The main class in this assembly is Layoutable.

Defines a XAML-like layout system using Measure and Arrange. Also defines LayoutManager which carries out the actual layout.


The main class in this assembly is Interactive.

Defines a system of routed events similar to those found in XAML.


The main class in this assembly is InputElement.

Handles input from various devices such as MouseDevice and KeyboardDevice, together with FocusManager for tracking input focus. Input is sent from the windowing subsystem to InputManager in the form of "Raw" events which are then translated into routed events for the controls.


There are many important classes in this assembly, but the root of them is Control.

Finally defines the actual controls. The Control class is analogous to WPF's FrameworkElement whereas the TemplatedControl class is our version of WPF's Control. This is also where you'll find all of the basic controls you'd expect.


Defines a default theme using a set of styles and control templates.


The main class in this assembly is Application.

This ties everything together, setting up the service locator, defining the default theme etc.


Adds utilities for debugging avalonia applications, such as DevTools which provides a Snoop/WPF Inspector/Browser DevTools window for inspecting the state of the application.