Using the Skia Desktop

Uno Platform supports running applications using a common Skia Desktop shell, which is automatically used based on the running platform, using a single build output using the net10.0-desktop target framework from the Uno.Sdk.

The currently supported targets and platforms are:

Linux X11
Linux Framebuffer
Windows (Using Win32 shell)
macOS (Using an AppKit shell)

The set of supported platforms can be defined by using the UnoPlatformHostBuilder, introduced in Uno Platform 5.2 and the Single Project support.

Get started with the Skia Desktop head

Follow the getting started guide for VS Code or Visual Studio, making sure to use the latest Uno Platform templates.

Once created, in the Platforms/Desktop/Program.cs file, you'll find the following builder:

csharp

var host = UnoPlatformHostBuilder.Create()
   .App(() => new App())
   .UseX11()
   .UseLinuxFrameBuffer()
   .UseMacOS()
   .UseWin32()
   .Build();

host.Run();

This builder allows us to configure the SkiaHost and setup which platforms will be supported at runtime. The builder evaluates the platform's availability one by one, in the order of definition.

Additional setup

Linux

[!includelinux-setup]

Troubleshooting OpenGL integration

Enabling debug logging messages for the Skia Host can help diagnose the render surface type selection.

In your App.xaml.cs file, change the minimum log level to:

csharp

builder.SetMinimumLevel(LogLevel.Debug);

Then change the logging level of the Skia Host to Information or Debug:

csharp

builder.AddFilter("Uno.UI.Runtime.Skia", LogLevel.Information);

You may also need to initialize the logging system earlier than what is found in Uno.UI's default templates by calling this in Main:

csharp

YourAppNamespace.App.ConfigureFilters(); // Enable tracing of the Skia host

Upgrading to a later version of SkiaSharp

By default, Uno Platform comes with a set of SkiaSharp dependencies.

If you want to upgrade SkiaSharp to a later version, you'll need to specify all packages individually in your project as follows:

xml

<ItemGroup>
   <PackagReference Include="SkiaSharp" Version="3.119.0" />
   <PackagReference Include="SkiaSharp.NativeAssets.Linux" Version="3.119.0" />
   <PackageReference Update="SkiaSharp.NativeAssets.macOS" Version="3.119.0" />
   <PackagReference Include="HarfBuzzSharp" Version="8.3.1.1" />
</ItemGroup>

Rendering Backend Selection

By default, Uno Platform uses OpenGL for hardware-accelerated rendering on desktop, with an automatic fallback to software rendering. You can override this per platform using the host builder:

csharp

var host = UnoPlatformHostBuilder.Create()
    .App(() => new App())
    .UseX11(b => b.RenderingBackend(X11RenderingBackend.Vulkan))
    .UseWin32(b => b.RenderingBackend(Win32RenderingBackend.Vulkan))
    .UseMacOS()
    .Build();

Each platform exposes its own RenderingBackend enum with only the backends it supports. For details, see Vulkan Rendering Backend.

Alternatively, you can use FeatureConfiguration.Rendering flags for backwards compatibility. The builder API takes precedence when both are used.

Windows Specifics

RDP Hardware Acceleration

The Uno Platform Skia Desktop runtime on Windows uses a WPF shell internally. By default, Uno Platform enables RDP hardware acceleration in order to get good performance, yet this feature is disabled by default in standard WPF apps with .NET 8.

If you're having issues with the Windows support for Skia Desktop over RDP, add the following to your project:

xml

<ItemGroup>
    <RuntimeHostConfigurationOption Include="Switch.System.Windows.Media.EnableHardwareAccelerationInRdp" Value="false" />
</ItemGroup>

X11 Specifics

When running using X11 Wayland compatibility (e.g. recent Ubuntu releases), DPI scaling cannot be determined in a reliable way. In order to specify the scaling to be used by Uno Platform, set the UNO_DISPLAY_SCALE_OVERRIDE environment variable. The default value is 1.0.

The X11 support uses DBus for various interactions with the system, such as file selection. Make sure that dbus is installed.

.NET Native AOT support

Building an Uno Platform Skia Desktop app with .NET (7+) Native AOT requires Uno Platform 4.7 (or later).

To build an app with this feature enabled:

Add the following property in your .csproj:

xml

<PropertyGroup>
   <PublishAot>true</PublishAot>
</PropertyGroup>

Add the following items in your .csproj:

xml

<ItemGroup>
   <TrimmerRootAssembly Include="MyApp" />
</ItemGroup>

Build your app with:
dotnetcli
```
dotnet publish -c Release -f net10.0-desktop
```
[!NOTE] Cross-compilation support is not supported as of .NET 7. To build a Native AOT app for Linux or Mac, you'll need to build on the corresponding host. [!NOTE] .NET Native AOT on Windows is not yet supported as WPF does not support it at this time.

Automatic Binding Preservation

When building an Uno Platform application head (for example, a Skia Desktop head) with Native AOT, Uno Platform automatically preserves public properties of types referenced by [Bindable] types to ensure data binding works correctly at runtime. This happens automatically when both IsUnoHead=true and PublishAot=true are set on the project (Uno head templates set IsUnoHead for you).

[!NOTE] Automatic binding preservation is only available for Uno Platform application heads. Class libraries or other projects that set PublishAot=true but are not marked with IsUnoHead=true will not get this behavior.

The build system:

Finds all types marked with Microsoft.UI.Xaml.Data.BindableAttribute or Uno.Extensions.Reactive.Bindings.BindableAttribute
Discovers types referenced by public properties of those bindable types
Generates an ILLink descriptor file to preserve the public properties (getters/setters) of discovered types

For example, if you have:

csharp

[Bindable]
public class MainViewModel
{
    public Entity MyEntity { get; set; }
}

public record Entity(string Name);

The build system will automatically preserve the Name property of Entity, allowing {Binding MyEntity.Name} expressions to work correctly in Native AOT builds.

For more information, see the runtime documentation and the .NET Native AOT documentation.