Author: Almir Vuk

Microsoft has announced the sixth preview of .NET 10, introducing a broad range of enhancements across the .NET Runtime, SDK, libraries, C#, ASP.NET Core, Blazor, and .NET MAUI. As stated in the official release, the update focuses on improving performance, developer experience, and cross-platform tooling.

In the realm of ASP.NET Core, memory management has been refined. Kestrel, IIS, and HTTP.sys now supports automatic eviction of unused memory from its internal pools when applications are idle. As reported, this change requires no developer action and is designed to reduce memory usage efficiently. Metrics for memory pools are now exposed under Microsoft.AspNetCore.MemoryPool, and developers can build custom memory pools using the new IMemoryPoolFactory interface.

Blazor also receives several key updates. A new  component offers more control over preloading framework assets, improving performance and base URL detection. Blazor WebAssembly projects can now generate output compatible with JavaScript bundlers like webpack by setting WasmBundlerFriendlyBootConfig to true, allowing, as stated, better integration with modern frontend pipelines.

Validation support in Blazor has been extended to include nested objects and collections within forms. This new capability is enabled through AddValidation() and the [ValidatableType] attribute. With a note that the attribute remains experimental and requires diagnostic suppression. Blazor diagnostics were improved as well, with traces for server circuits now exposed as top-level activities, simplifying telemetry in tools like Application Insights.

Blazor Server now supports persisting circuit state, allowing users to resume activity after reconnecting, even after server-side eviction. Developers can control circuit behavior through the new Blazor.pause() and Blazor.resume() APIs, as explained this will help reduce server resource consumption during idle periods.

Navigation behavior in Blazor was updated for consistency, with a configuration switch now opt-in to disable NavigationException usage. ASP.NET Core Identity now includes support for passkeys, enabling modern, phishing-resistant authentication using the WebAuthn and FIDO2 standards. The Blazor Web App template includes built-in support for this.

Minimal APIs can now integrate validation error responses using IProblemDetailsService, offering more consistent and customizable error output. As reported, the validation APIs have moved to a new Microsoft.Extensions.Validation package and namespace, broadening their usage beyond ASP.NET Core.

Regarding the .NET MAUI, the MediaPicker component was enhanced to support multiple file selection and in-API image compression. Developers can also now intercept web requests within BlazorWebView and HybridWebView, enabling advanced scenarios like modifying headers or injecting custom responses.

Furthermore, various UI fixes were implemented across controls, including CollectionView, CarouselView, and SearchBar, along with memory leak resolutions and improved rendering on Windows, Android, and iOS. Additionally, .NET now supports Android API levels 35 and 36, and includes diagnostics and interop performance improvements. On Apple platforms, the release aligns with Xcode 16.4 and brings reliability and runtime enhancements.

The .NET SDK introduces major improvements for tool authors, including support for platform-specific tools within a single package, and the new dotnet tool exec command, which, as described in the official docs, allows one-shot execution without installation. Also the lightweight dnx script further simplifies tool execution.

CLI introspection capabilities were extended with the –cli-schema option, which outputs a machine-readable JSON representation of commands, aiding automation and scripting. File-based apps received additional improvements, including support for native AOT publishing, project references, and enhanced shebang support for shell execution.

For interested readers, full release notes and further technical documentation are available on the official .NET documentation, also the developers can join the GitHub discussion.

Earlier this month, Microsoft announced the release of .NET 10 Preview 5, delivering updates across multiple components, including ASP.NET Core, .NET MAUI, Windows Presentation Foundation (WPF), and Entity Framework Core. As reported, this preview introduces new features and improvements aimed at enhancing developer productivity, application observability, and customization.

Regarding ASP.NET Core, a new capability allows developers to configure custom security descriptors for HTTP.sys request queues via the RequestQueueSecurityDescriptor property in HttpSysOptions. As stated, this feature offers better control over access to request queues at the OS level.

Additionally, validation resolver APIs supporting Minimal APIs have been marked as experimental to allow future modifications, though the top-level AddValidation APIs remain stable.

OpenAPI generation has been improved with support for version 3.1. The release also extends metadata extraction from XML documentation, recognizing and  tags for response descriptions.

Furthermore, the Blazor framework introduces a method for easier rendering of Not Found pages by specifying a NotFoundPage component in the router configuration. As mentioned in the release notes, this approach is prioritized over the older NotFound fragment and is now included in default project templates.

    
        
        
    
    This content will be ignored because we have NotFoundPage defined.

Notable addition in the Preview 5 is the introduction of detailed metrics and tracing capabilities for Blazor apps. As noted, Metrics are published via dedicated meters for components, lifecycle events, and server circuits.

Tracing uses a new Microsoft.AspNetCore.Components activity source includes detailed instrumentation for navigation, event handling, and circuit lifecycles.

With a note that developers can enable these diagnostics by configuring OpenTelemetry to collect data from the corresponding sources and meters.

builder.Services.ConfigureOpenTelemetryMeterProvider(meterProvider =>
{
    meterProvider.AddMeter("Microsoft.AspNetCore.Components");
    meterProvider.AddMeter("Microsoft.AspNetCore.Components.Lifecycle");
    meterProvider.AddMeter("Microsoft.AspNetCore.Components.Server.Circuits");
});

builder.Services.ConfigureOpenTelemetryTracerProvider(tracerProvider =>
{
    tracerProvider.AddSource("Microsoft.AspNetCore.Components");
});

In <a href="http://.NET MAUI, support has been added for XAML Global and Implicit Namespaces. These features simplify markup by allowing developers to use controls without specifying multiple xmlns declarations. A new global namespace can include custom views, converters, and third-party libraries, enabling cleaner and more maintainable XAML.

Implicit namespaces can be activated through project properties, reducing the need for verbose declarations. However, Microsoft notes that tooling errors may occur while this feature remains in preview.

For more information on these features, David Ortinau, Principal Product Manager at Microsoft, has published a dedicated blog post covering the latest updates in .NET MAUI.

Another notable addition to .NET MAUI is the ability to intercept web requests in HybridWebView. This is now possible by handling the WebResourceRequested event, developers can alter or block requests, enabling scenarios such as injecting custom headers or serving local resources.

The update for .NET for Android and Apple platforms, such as iOS, macOS, and tvOS, primarily focuses on quality and stability improvements. Specific details are available in the respective GitHub repositories.

WPF introduces a shorthand syntax for Grid.RowDefinitions and Grid.ColumnDefinitions, making XAML as explained, more concise, and this will improve Hot Reload support.

Font and globalization enhancements include the addition of the simsun-extg font to improve rendering in East Asian languages. Also, the Fluent theme has been refined, addressing crashes and improving styling for RTL layouts. Performance gains were achieved by reducing memory allocations and removing unused code paths.

Lastly, Entity Framework Core 10 Preview 5 brings the ability to define custom names for default constraints, providing more control over database schema generation. Developers can now assign constraint names directly in model configuration or enable automatic naming for all default constraints using UseNamedDefaultConstraints.

For interested readers, full release notes with all updates, fixes, and known issues are available through Microsoft’s official documentation and GitHub repositories.

The .NET team has released Dev Proxy version 0.28, introducing new capabilities to improve observability, plugin extensibility, and integration with AI models. A central feature of this release is the OpenAITelemetryPlugin, which, as reported, allows developers to track usage and estimated costs of OpenAI and Azure OpenAI language model requests within their applications.

The plugin intercepts requests and records details such as the model used, token counts (prompt, completion, and total), per-request cost estimates, and grouped summaries per model.

According to the announcement, this plugin supports deeper visibility into how applications interact with LLMs, which can be visualized using external tools like OpenLIT to understand usage patterns and optimize AI-related expenses.

The update also supports Microsoft’s Foundry Local, a high-performance local AI runtime stack introduced at the Build conference last month. Foundry Local enables developers to redirect cloud-based LLM calls to local environments, reducing cost and enabling offline development.

As stated, Dev Proxy can now be configured to use local models, quoting the following from the dev team: 

Our initial tests show significant improvements using Phi-4 mini on Foundry Local compared to other models we’ve used in the past. We’re planning to integrate with Foundry Local by default, in the future versions of Dev Proxy.

To configure Dev Proxy with Foundry Local, developers can specify the local model and endpoint in the languageModel section of the proxy’s configuration file. This integration offers a cost-effective alternative for developers working with LLMs during local development.

Regarding the .NET Aspire users, a preview version of Dev Proxy extensions is now available. These extensions simplify integration with Aspire applications, allowing Dev Proxy to run either locally or via Docker with minimal setup. As reported, this enhancement improves portability and simplifies the configuration process for distributed development teams.

In addition, support for OpenAI payloads has been expanded. As stated, previously limited to text completions, Dev Proxy now includes support for a wider range of completion types, increasing compatibility with OpenAI APIs.

The release also brings enhancements to TypeSpec generation. In line with TypeSpec v1.0 updates, the plugin now supports improved PATCH operation generation, using MergePatchUpdate to clearly define merge patch behavior.

As noted in the release, Dev Proxy now supports JSONC (JSON with comments) across all configuration files. This addition enables developers to add inline documentation and annotations, which can aid in team collaboration and long-term maintenance.

Concurrency improvements have also been made in logging and mocking. These changes ensure that logs for parallel requests are grouped accurately, helping developers trace request behavior more effectively.

Two breaking changes are included in this release. First, the GraphConnectorNotificationPlugin has been removed, following the deprecation of Graph connector deployment via Microsoft Teams.

Furthermore, the –audience flag in the devproxy jwt create command has been renamed to –-audiences, while the shorthand alias -a remains unchanged.

The CRUD API plugin has been updated with improved CORS handling and consistent JSON responses, enhancing its reliability in client-side applications.

Finally, the Dev Proxy Toolkit for Visual Studio Code has been updated to version 0.24.0. This release introduces new snippets and commands, including support for the already mentioned OpenAITelemetryPlugin, also improved Dev Proxy Beta compatibility, and better process detection.

For interested readers, full release notes are available in the official repository, providing a complete overview of features, changes, and guidance for this version

The Uno Platform team has announced the general availability of Uno Platform 6.0 and Uno Platform Studio, introducing a broad set of enhancements aimed at improving developer productivity and cross-platform performance.

As stated in an official blog post, Uno Platform Studio is built on top of the open-source Uno Platform, and it delivers an easier development workflow for developers to build and ship .NET applications more efficiently using a single codebase.

One of the major highlights is Hot Design, a runtime visual designer now reaching general availability. Hot Design allows developers to pause a running application, visually edit the UI, and resume the session without restarting. This approach differs from traditional WYSIWYG tools by offering live editing of complex UIs directly within the application.

Uno Platform 6.0 introduces support for a unified Skia-based rendering engine across all platforms — including iOS, Android, WebAssembly, Windows, macOS, and Linux — running alongside existing native implementations. This approach, as explained, brings consistent, high-performance rendering using hardware acceleration across devices, while still allowing native rendering paths where applicable.

Regarding the performance and improvements, the team stated the following:

Uno Platform 6.0 is the best and the fastest Uno Platform yet, which now comes with a new unified rendering engine which provides massive improvements on app startup times, and hyper-performance on UI rendering – up to 75% smaller footprint, 60% faster startup, 30% less memory and 45X faster to run. 

According to the Uno team, startup times have improved significantly. The official blog post stated the tests on an iPhone 13, which showed a drop from 1.5 seconds to 0.49 seconds. The rendering engine also reduces application footprint by up to 75%, improves startup speed by 60%, lowers memory usage by 30%, and boosts execution speed up to 45 times.

Additionally, the release introduces support for new components and features. A cross-platform MediaPlayerElement is now available, enabling video playback across all platforms using platform-specific backends such as libvlc and native players. WebView2, which allows navigation to web content and integration with JavaScript, is now supported on all targets, including a new GTK4-based implementation for Linux.

Significant progress was also made on application size and deployment optimizations. The Windows backend now supports a Win32 implementation instead of WPF, allowing for full IL trimming and reducing the size of self-contained apps by 100 MB. Combined with new XAML and resources trimming support for iOS and desktop targets, blank app sizes have been, as reported, reduced by 74% on Windows and 21% on iOS. These reductions also lead to a 35% improvement in build times when using ahead-of-time (AOT) compilation.

With this release, the team also introduced a new Uno.WinRT package, which exposes a wide range of non-UI cross-platform APIs for filesystem access, sensors, media handling, and hardware devices. By separating UI and non-UI capabilities, developers can now build libraries that rely solely on runtime features without including UI dependencies, simplifying cross-platform targeting and reducing package overhead.

As stated by the Uno team, the platform remains open source and free under the Apache 2.0 license. Core features, including development tools and critical components like DataGrid and WebView2, are guaranteed to stay open. Premium tooling, such as Uno Platform Studio, provides optional commercial support and enhancements while sustaining the development model.

Other changes in this release include improvements to Automated App Packaging, deprecation of UWP support, enhanced tooling integration, and more.

For interested readers, full release notes detailing all updates and changes are available on the official Uno Platform website.

Last week, the .NET Team announced the second preview release of .NET 10 introducing several enhancements across various components, including .NET Runtime, SDK, libraries, C#, ASP.NET Core, Blazor, .NET MAUI, and more.

One of the key updates in ASP.NET Core focuses on improving both the user experience and development flexibility. A notable addition is the ReconnectModal component for Blazor Web App projects. This new UI component gives developers more control over the reconnection process when a client loses its WebSocket connection.

As stated, the component is bundled with its own stylesheet and JavaScript files, ensuring it adheres to stricter Content Security Policy (CSP) settings. Developers can now better manage the reconnection state with new features such as the retrying state and an event to signal state changes.

Furthermore, the NavigateTo function in Blazor has been updated to prevent the browser from scrolling to the top of the page when navigating to the same page, improving the user experience by maintaining the scroll position.

Another update to the NavLink component allows it to ignore query strings and fragments when using NavLinkMatch.All, offer more precise control over link-matching behavior. Also, a new method, CloseColumnOptionsAsync, is introduced for closing column options in the QuickGrid component, simplifying UI interactions.

Continuing from Preview 1, the XML documentation comments are now included in OpenAPI documents when using ASP.NET Core, providing as stated, richer metadata for APIs. This feature requires enabling XML documentation in the project file and is processed at build-time.

A note for the developers that a new upgrade to OpenAPI.NET v2.0.0-preview7 brings several improvements, including breaking changes that affect document transformers and other OpenAPI operations.

In .NET MAUI, several new features are introduced, including the ShadowTypeConverter for improved shadow styling, which supports flexible shadow configurations using formatted strings. The SpeechOptions API now includes a Rate property to control the playback speed for text-to-speech functionality.

A platform-specific update allows modals to be displayed as popovers on iOS and Mac Catalyst, giving developers more control over modal presentations. The Switch control now supports setting an OffColor in addition to the existing OnColor. The HybridWebView component introduces a new InvokeJavascriptAsync method, simplifying the interaction with JavaScript in WebView controls.

Entity Framework Core 10 in this preview adds support for the RightJoin operator, allowing developers to perform right joins in queries, complementing the previously introduced LeftJoin operator. Small improvements have also been made to optimize database root handling and other internal processes.

WPF has seen performance improvements, particularly in UI automation, file dialogs, and pixel format conversions. Bug fixes in Fluent style components have addressed issues with default styles for Label and animation for the Expander controls. Several other bug fixes have been applied, including resolving issues with text pointer normalization and localization for various UI components.

C# 14 introduces partial instance constructors and events, expanding the range of partial members that can be used in classes. These features, along with partial methods and properties introduced in previous versions, enhance the flexibility and modularity of class implementations, especially for use with source generators.

For those interested in further details and other changes, the full release notes are available, offering an in-depth look at the second preview of .NET 10.

At the end of February, .NET 10 Preview 1 was released, bringing several major updates and improvements across the platform. This first preview introduces enhancements to the .NET Runtime, SDK, libraries, C#, ASP.NET Core, Blazor, .NET MAUI, and more.

ASP.NET Core in .NET 10 now supports OpenAPI 3.1. This allows developers to generate OpenAPI documents with better integration for JSON Schema draft 2020-12. The release also introduces a simplified method for configuring OpenAPI versions. However, there are breaking changes that require updates to applications using document transformers.

Another noteworthy improvement is the ability to serve OpenAPI documents in YAML format. This provides a more concise alternative to JSON, helping developers manage longer descriptions more efficiently.

Regarding the future of this support, the .NET team states the following:

Support for YAML is currently only available when served at runtime from the OpenAPI endpoint. Support for generating OpenAPI documents in YAML format at build time will be added in a future preview.

Additional updates include response descriptions for ProducesResponseType, and URL validation with RedirectHttpResult.IsLocalUrl, and improved integration testing for applications using top-level statements.

Moving on to Blazor, QuickGrid now includes a RowClass parameter for conditional styling. Additionally, Blazor scripts are now served as static web assets with improved precompression. This change significantly reduces file sizes, offering a more efficient experience for developers.

As reported, .NET MAUI Preview 1 focuses on quality improvements for iOS, Mac Catalyst, Android, and other platforms. Notably, CollectionView handlers for iOS and Mac Catalyst are now enabled by default, improving both performance and stability.

The release also brings support for Android 16 (Baklava) Beta 1. It introduces new recommendations for the minimum supported Android API, now set to API 24. Additionally, JDK-21 support has been added. .NET Android projects can now run using the dotnet run command, simplifying the development process. Trimmer warnings are enabled by default for iOS, macOS, and tvOS applications, prompting developers to address potential trimming issues in their code.

On the database side, Entity Framework Core 10 Preview 1 introduces several new features. First, there is first-class LINQ support for the LeftJoin operator, simplifying queries that previously required complex LINQ constructs. The release also makes working with ExecuteUpdateAsync easier by supporting regular non-expression lambdas.

Other optimizations include improvements to SQL Server scaffolding, date/time function translation, and performance for Count operations on ICollection. Additionally, smaller improvements address optimizations for MIN/MAX over DISTINCT and better handling of multiple consecutive LIMIT operations.

In C# 14, several new features have been added. One of the key updates is support for field-backed properties, providing a smoother path for developers transitioning from auto-implemented to custom properties. The nameof expression now supports unbound generics. Implicit conversions for Span and ReadOnlySpan also make working with these types more intuitive.

Moreover, lambda expressions can now include parameter modifiers like ref and in without specifying types. An experimental feature allows developers to change how string literals are emitted into PE files, offering potential performance benefits. Stating the following:

By turning on the feature flag, string literals (where possible) are emitted as UTF-8 data into a different section of the PE file without a data limit. The emit format is similar to explicit UTF-8 string literals.

Lastly, the .NET Team called on viewers to watch an unboxing video where they discussed what was new in the preview release, featuring live demos from the dev team. The video is now available to watch on demand and for a complete overview, readers can explore the full release notes and dive into additional details about the first preview of .NET 10.

Last week, Microsoft released the first release candidate for the upcoming .NET 9 framework, which includes a range of updates across its core components, such as the .NET Runtime, SDK, libraries, C#, and frameworks like ASP.NET Core and .NET MAUI.

Regarding the .NET libraries, new APIs were added to ClientWebSocketOptions and WebSocketCreationOptions, enabling developers to configure WebSocket pings and automatically terminate connections if no response is received within a specified timeframe.

Additionally, new types—ZLibCompressionOptions and BrotliCompressionOptions—have been introduced, providing more detailed control over compression levels and strategies. These additions offer greater flexibility compared to the previous CompressionLevel option.

For users working with TAR archives, the public property DataOffset has been introduced in System.Formats.Tar.TarEntry allows access to the position of data in the enclosing stream. This provides the location of the entry’s first data byte in the archive stream, making it easier to manage large TAR files, including concurrent access features.

From this version, LogLevel.Trace events generated by HttpClientFactory will now exclude header values by default. However, developers can log specific header values using the RedactLoggedHeaders helper method, enhancing privacy and security.

Furthermore, the new command dotnet workload history has been introduced. As explained, this command tracks the history of workload installations or modifications within a .NET SDK installation, offering insights into workload version changes over time. It is intended to assist users in managing workload versions more efficiently, as stated similar to Git’s reflog functionality.

The release candidate also introduces updates to ASP.NET Core, such as a keep-alive timeout for WebSockets, support for Keyed DI services in middleware, and improvements to SignalR distributed tracing, aiming to improve performance and simplify development workflows.

Interested readers can read more about  ASP.NET Core RC1 updates in the latest and detailed InfoQ news article.

Regarding .NET MAUI the release focuses on addressing issues and stabilizing the platform in preparation for the general availability (GA) release. Among the new features is HorizontalTextAlignment.Justify, which provides additional text alignment options for Labels. Also, updates to HybridWebView are included, with a guide for developers upgrading from .NET 9 Preview 7 to RC1, especially about Invoking JavaScript methods from C#.

With a note that .NET for Android and iOS in this release, are primarily focused on quality improvements, as reported this release requires Xcode 15.4 for building applications.

Lastly, looking into the community discussion for this release, an interesting conversation clarified that the Out-of-proc Meter wildcard listening feature is a new feature not previously available in either in-process or out-of-process scenarios. 

Tarek Mahmoud Sayed, collaborator on .NET project, wrote the following:

The wildcard support is the new feature that was not supported in proc or out of proc. The sample showing the in-proc just for simplicity to show using the wildcard. You can still listen out-of-proc too and leverage the wildcard feature. We are working to make diagnostics tools like dotnet monitor to leverage the feature too. Let me know if there still anything unclear and I’ll be happy to clarify more.

Interested readers can find more information about this version in the official release notes. Lastly, the .NET 9 Release Candidate 1 download is available for Linux, macOS, and Windows.

.NET Aspire 8.2 has been officially released, bringing enhancements focused on onboarding, testing, and overall quality-of-life improvements. A significant change in this version is the renaming of Components to Integrations. As explained, the term Integrations now means packages that assist with the setup, initialization, and interaction with major cloud services and platforms.

The .NET Aspire team clarified this change in terminology:

We originally named these components because… well… they’re components! But we’ve realized that it’s such an overloaded term in development that we were actually just confusing people (and ourselves). Our documentation has been updated to reflect the change to Integrations and we will be using that terminology in our content moving forward.

In .NET Aspire 8.2, Integrations are utilized in two main ways. First, as a Hosting package that was added to the AppHost project, which simplifies launching resources and connecting them during local development. Second, as a package within the application code, this makes easier the process of connecting to resources created in the AppHost and simplifies the setup and configuration of new cloud services.

The release also includes improvements in testing procedures. The .NET Aspire team, with contributions from the community, has expanded its suite of tests to ensure that updates to Integrations do not disrupt existing applications. This enhancement aims to facilitate smoother version upgrades and minimize potential issues.

A significant breaking change in .NET Aspire 8.2 involves a known issue with building projects that reference version 8.1.0 when the 8.2.0 workload is installed. Users are advised to ensure their AppHost project references the latest version of the Aspire.Hosting.AppHost package by including the following line in the project file.

Looking ahead to .NET Aspire 9.0, the team is working on enabling project builds without requiring the .NET Aspire Workload to be installed. This change is expected to benefit continuous integration and deployment scenarios by reducing the need for workload installation on build machines.

It is also stated that the progress towards this goal has been made in version 8.2 by moving some components to separate packages, which projects will automatically reference. This change is anticipated to be mostly transparent to users but requires updating to the latest version of the workload and package references. An open GitHub issue provides further details on these topics for interested readers.

Community feedback on this release has been generally positive. Users have requested additional features, such as a SignalR Integration to manage hub connection URLs and ports, and improvements in documentation for deployment and issues with Azure App Service. Lastly, the official release notes hold more information about this release for interested readers.

.NET Aspire 8.2 has been officially released, bringing enhancements focused on onboarding, testing, and overall quality-of-life improvements. A significant change in this version is the renaming of Components to Integrations. As explained, the term Integrations now means packages that assist with the setup, initialization, and interaction with major cloud services and platforms.

The .NET Aspire team clarified this change in terminology:

We originally named these components because… well… they’re components! But we’ve realized that it’s such an overloaded term in development that we were actually just confusing people (and ourselves). Our documentation has been updated to reflect the change to Integrations and we will be using that terminology in our content moving forward.

In .NET Aspire 8.2, Integrations are utilized in two main ways. First, as a Hosting package that was added to the AppHost project, which simplifies launching resources and connecting them during local development. Second, as a package within the application code, this makes easier the process of connecting to resources created in the AppHost and simplifies the setup and configuration of new cloud services.

The release also includes improvements in testing procedures. The .NET Aspire team, with contributions from the community, has expanded its suite of tests to ensure that updates to Integrations do not disrupt existing applications. This enhancement aims to facilitate smoother version upgrades and minimize potential issues.

A significant breaking change in .NET Aspire 8.2 involves a known issue with building projects that reference version 8.1.0 when the 8.2.0 workload is installed. Users are advised to ensure their AppHost project references the latest version of the Aspire.Hosting.AppHost package by including the following line in the project file.

Looking ahead to .NET Aspire 9.0, the team is working on enabling project builds without requiring the .NET Aspire Workload to be installed. This change is expected to benefit continuous integration and deployment scenarios by reducing the need for workload installation on build machines.

It is also stated that the progress towards this goal has been made in version 8.2 by moving some components to separate packages, which projects will automatically reference. This change is anticipated to be mostly transparent to users but requires updating to the latest version of the workload and package references. An open GitHub issue provides further details on these topics for interested readers.

Community feedback on this release has been generally positive. Users have requested additional features, such as a SignalR Integration to manage hub connection URLs and ports, and improvements in documentation for deployment and issues with Azure App Service. Lastly, the official release notes hold more information about this release for interested readers.

At the end of July, Avalonia 11.1 has been released. It is labeled as a point release, but as stated in the official release post, the volume of improvements suggests a major upgrade for developers. The project changes are related to Performance Optimizations, UI and UX Improvements, Developer Productivity, Graphics and Animation Enhancements, and more.

For readers who are unaware, Avalonia UI is an open-source and cross-platform UI framework for .NET developers, designed to facilitate the development of desktop applications that can run on Windows, macOS, Linux, iOS, Android, and WebAssembly. Correspondingly, last year, InfoQ also interviewed Mike James, the company’s current CEO, which readers can read and get more insights into the Avalonia UI platform.

The update enhances cross-platform support, notably adding compatibility with Samsung Tizen and Apple TV. This expansion allows developers to target smart TVs, and the Avalonia team states the following:

These new capabilities are particularly exciting for developers aiming to extend their applications into the living room or create unique TV-based experiences.

Browser support has also seen a few improvements, with a new software renderer that boosts performance and compatibility. The framework now supports multiple AvaloniaView instances, making it suitable for complex web applications. On mobile, updates to the Android and iOS backends include fixes for input handling, keyboard interactions, and general stability, improving user and developer experiences.

Performance has been a focal point of Avalonia 11.1. The introduction of a new Vulkan rendering backend offers notable performance benefits, as reported providing more control over GPU resources and improving rendering efficiency.

Other optimizations include enhancements to the rendering pipeline, resulting in smoother animations and faster UI updates. Resource management has also been improved, with better caching and lazy loading, reducing memory usage and speeding up application startup times.

User interface and user experience (UI/UX) enhancements include the addition of a HyperlinkButton control, making it easier to implement clickable links. The tooltip system has been updated, offering features like tooltip chaining and the BetweenShowDelay property for more sophisticated tooltip behavior. The ScrollViewer component has been improved for smoother scrolling, adapting to various input methods.

Developer productivity features have been bolstered, with enhancements to DevTools, including a focus follower and the ability to pin properties. Also, XAML improvements now offer better handling of generics, more efficient compiled bindings, and improved diagnostics.

The binding system has been refined, with better support for MultiBinding and ICommand bindings in style setters. The new FuncValueConverter provides more flexible data conversion options.

Graphics and animation capabilities have expanded, with support for new pixel formats like Rgb32 and Bgr32, enhancing image handling efficiency. TileBrush and DrawingBrush have been improved for more complex graphical effects.

Furthermore, the animation system has been refined, ensuring smoother animations and better performance.

A Reddit thread discussing the Avalonia project has yielded notable insights, particularly with the participation of Mike James, the current CEO of the Avalonia project. James mentioned that WebOS support might be a future possibility, noting that one of the community members was working on adding WebOS support, but not 100% sure what the current status is.

The rest of the community’s feedback was generally positive, with questions focusing on Avalonia’s stability compared to .NET MAUI and its overall performance.

Additional project changes include updates in accessibility, internationalization, mobile-specific enhancements, new windowing features, file system integration, and build and deployment improvements.

Lastly, the full release notes are available on the project’s official website, and interested readers are encouraged to explore.