Over 90 improvements in this release! Uno Platform 4.4 is our 4th release in 2022, …
It has been just over 3 months since our 4.0 release, and we’ve used that time to focus on performance as well as bringing the latest .NET 6 innovation to Uno Platform. By simply updating your application to the newest bits you will notice a significant boost to your app performance.
This release packs over 200 new feature requests, bugs, and issues you raised. We welcomed a few great contributions from our community, which is now over 210 contributors strong! Thanks for all you bring to Uno Platform.
Let’s unpack the 4.1 release.
For this release, we’ve made numerous changes to a wide range of parts from the Uno Platform, such as Style resolution, layout and measure pass performance, memory consumption and allocations which result in up to 30% performance improvements in some scenarios.
The measure pass (MeasureOverride and InvalidateMeasure) is an important contributor to the computations performed to layout the UI, and any optimization performed in this area can significantly improve the time to show the first UI or improve binding update.
We’ve changed the way MeasureOverride is invoked when InvalidateMeasure is called, where previously all ancestors of a control would be re-executing MeasureOverride, even if their size was not changing. With the new update, MeasureOverride is not invoked recursively if the size is not changing and only for the elements that need it. This change is called dirty path invalidation, allowing the skipping of elements that don’t have their size invalidated.
This new optimization allows for UI that changes elements deep in the visual tree to have minimal impact on their parents, making changes more responsive.
This optimization is currently available for WebAssembly and Skia backends. We’re working to get this improvement on Android and iOS soon.
Troubleshooting memory issues is not an easy task but can be made more efficient with tooling. .NET WebAssembly is not providing such tooling, but as it uses the Mono virtual machine underneath, tools found in the Xamarin space can be used given the right input.
We took the task of enabling memory profiling for WebAssembly, by including the mono logging profiler in the runtime, giving the ability to create memory profiles that can be opened using the Xamarin Profiler.
For those new to Uno Platform – it allows for creation of pixel-perfect, single-source C# and XAML apps which run natively on Windows, iOS, Android, macOS, Linux and Web via WebAssembly. Uno Platform is free and Open Source (Apache 2.0) and available on GitHub.
This change is now available as part of Uno.Wasm.Bootstrap 3.2 and later can be enabled easily by setting new flags in the project file.
You can head to the documentation on how to profile the memory of your Uno Platform WebAssembly application.
Memory allocations during critical paths of the layout and rendering has also been improved significantly. Reducing allocations is reducing the time spent managing memory by the GC, improving the overall performance of the application.
These improvements were done through the inclusion of an Array Pooling system linked to the MemoryManager class. This allows for dynamic management pooled arrays based on the memory pressure detected by the GC.
Additionally, a refactoring of delegate and lambda-based pieces of code was included. In many cases, using C# lambdas makes code easy to read, but can have adverse effects on multicast delegates invocations, display class creations and memory allocations of multicast delegates (64 bytes each under monovm). Replacing those with simple classes with either interface virtual methods invocations both improves memory allocation and invocation performance. Additionally, on WebAssembly AOT, delegates are creating a very costly interpreter/AOT transition. Virtual methods invocations don’t have this issue.
We’re happy to introduce an open-source tool called XAML Merger to enhance the performance of applications. This is an enhancement of Microsoft’s WinUI Resource Dictionaries merging tool used in WinUI 2.x, providing it in an easy-to-use NuGet package internal compatible with UWP/WinAppSDK and Uno Platform projects.
Merging dictionaries has a great impact on all platforms, including UWP and WinUI. For instance, resolving a single resource in Uno.Material went down 32% in WinAppSDK on Windows with resources merged.
ResourceDictionary XAML files are a central part of the styling system of XAML-based platforms. For readability, in most cases, dictionaries are split in many files (one per control type, generally) in applications and Uno itself, requiring the use of “Merged Dictionaries”. Those merged dictionaries cannot lookup up in the tree for color resources, and developers generally tend to add duplicate inner merged dictionaries referencing color or brushes to have a common look and feel for controls.
This architecture allows for dictionaries to be used as a single entity which recursively looks up every inner dictionary for resources, creating an individual Dictionary<,> lookups through a linear walking of the merged dictionary tree.
While this choice makes the developer’s life easier, it is also very computation intensive. During static resources resolution, the Application.Resources dictionary is queried extremely often to resolve templates and their resources.
To reduce the impact of these lookups, merging dictionaries is a good way to get a single dictionary lookup, greatly improving the creation time of UI elements.
For example, Uno Platform had an internal number of dictionaries for all controls of about 81. This number could also be added to Uno.Material and any other library which uses individual resource dictionaries for its styles and resources.
Uno Platform now brings the support for Android 12 SDK and its dependencies and removes the support for Android 10 SDK. As a reminder, this only means that you need to build your application with Android SDKs 11 or 12, and your application can still run properly on Android 5 or later.
Note that building for Android 12 is easier when using Visual Studio 2022, where the JDK 11 is installed automatically, without any additional setup.
The .NET team has introduced the Preview 13 of their mobile bindings, introducing a set of low-level breaking changes in the macOS and iOS APIs. This change is unlikely to impact most net6 Uno applications, but libraries that make use of the “native” primitives such as `nint` and `nfloat` will require some code changes.
To build your application for Uno 4.1 and Visual Studio 2022 17.2 Preview 1, you’ll need to run uno-check first.
Note that Visual Studio 17.0 and 17.1 stable builds are not supported for .NET 6 mobile targets so naturally Uno Platform will face the same constraints.
It’s also worth noting that in .NET 6 mobile Preview 14 Microsoft will introduce an additional (and likely final) set of binary breaking changes, and we’ll publish an update to Uno NuGet package.
Once you have 17.2 Preview 1 or later installed, use `uno-check –preview` to set up your environment.
We’re also updating the Visual Studio Code integration with:
Improvements over code changes detection, so that code completion shows up-to-date content from code in your application
The ability to set a port number the remote-control tooling, which can be particularly useful when you publish your application in a containeri.
Head over to our VS Code plugin to get started!
The Uno Platform Plugin for Figma is an Uno Platform WASM application. Therefore, all performance updates we made in 4.1 are automatically included in the plugin, making it faster on launch and updates. In addition, we spent a lot of time documenting the plugin so you can more easily try it out.
The best way to try the plugin is to go through the quick start and run the eCommerce sample application.
If you are new to Uno Platform, the best way to get started is to follow our official getting started guide. Before you get started, make sure you’ve prepared your dev environment for Uno Platform app development.
The tutorial walks you through creating a small multi-platform application with Uno Platform and how to run your applications on all platforms supported by Uno Platform.
Jerome Laban, CTO, Uno Platform