dotnet-ui-chooser

Imported from wshaddix/dotnet-skills (skills/dotnet-ui-chooser/SKILL.md). Install upstream with npx skills add wshaddix/dotnet-skills --skill dotnet-ui-chooser. Copyright stays with the author.

dotnet-ui-chooser

UI framework selection decision tree for .NET applications. Covers Web (Blazor Server, Blazor WebAssembly, Blazor Hybrid), cross-platform (MAUI, Uno Platform, Avalonia), and Windows-only (WinUI 3, WPF, WinForms) frameworks. Presents structured trade-off analysis across five decision factors to help teams evaluate options based on their specific constraints.

Scope boundary: This skill owns the framework selection decision tree and cross-framework comparison. Individual framework depth, patterns, and APIs are owned by the respective framework skills. Migration guidance between frameworks is owned by [skill:dotnet-wpf-migration].

Out of scope: Framework-specific implementation patterns -- see individual skills listed below. Migration paths between frameworks -- see [skill:dotnet-wpf-migration]. Desktop UI testing -- see [skill:dotnet-ui-testing-core].

Cross-references: [skill:dotnet-blazor-patterns] for Blazor hosting and render modes, [skill:dotnet-maui-development] for MAUI patterns, [skill:dotnet-uno-platform] for Uno Platform patterns, [skill:dotnet-winui] for WinUI 3 patterns, [skill:dotnet-wpf-modern] for modern WPF on .NET 8+, [skill:dotnet-winforms-basics] for WinForms modernization.

Decision Tree

Use this structured flow to narrow framework choices based on project constraints. Each branch presents trade-offs rather than definitive answers -- the right choice depends on the weight your team assigns to each factor.

Step 1: Target Platforms

The most significant constraint. Identify which platforms the application must support.

Target platforms?
|
+-- Web browser only
|   --> Blazor (Server, WebAssembly, or Auto)
|       See "Blazor Hosting Model Selection" below
|
+-- Windows only
|   --> WinUI 3, WPF, or WinForms
|       See "Windows Framework Selection" below
|
+-- Mobile (iOS / Android)
|   +-- Also need desktop?
|   |   +-- Yes --> MAUI or Uno Platform
|   |   +-- No  --> MAUI or Uno Platform
|   |
|   +-- Also need web?
|       +-- Yes --> Uno Platform (WASM target) or Blazor Hybrid in MAUI
|       +-- No  --> MAUI or Uno Platform
|
+-- All platforms (web + mobile + desktop)
|   --> Uno Platform (broadest reach)
|       or Blazor Hybrid in MAUI (web UI, native shell)
|
+-- Desktop cross-platform (Windows + macOS + Linux)
    --> Uno Platform or Avalonia
        MAUI supports macOS/Windows but not Linux

Step 2: Team Expertise

Match frameworks to existing team skills to reduce ramp-up time.

Step 3: UI Complexity

Match the UI requirements to framework rendering capabilities.

Step 4: Performance Needs

Framework rendering architecture affects performance characteristics.

Step 5: Migration Path

If modernizing an existing application, the source framework constrains viable targets.

Blazor Hosting Model Selection

When Blazor is the target, select a hosting model based on interactivity needs, deployment constraints, and scale.

For detailed Blazor patterns, see [skill:dotnet-blazor-patterns].

Windows Framework Selection

When the application targets Windows only, choose based on UI richness, team expertise, and modernization goals.

Comparison Table

When to Choose Each

WinUI 3 -- best for new Windows-native applications that need modern Fluent Design, touch/pen input, and the latest Windows integration (widgets, notifications, Mica). Requires Windows 10 2004+. See [skill:dotnet-winui].

WPF on .NET 8+ -- best for teams with existing WPF expertise, applications that need the rich WPF control ecosystem, or projects migrating from WPF on .NET Framework. Fluent theme available in .NET 9+. See [skill:dotnet-wpf-modern].

WinForms on .NET 8+ -- best for rapid prototyping, internal tools, simple CRUD forms, and Windows utilities where development speed matters more than UI polish. Simplest learning curve. See [skill:dotnet-winforms-basics].

Cross-Platform Framework Selection

When the application must run on multiple platforms, compare reach, rendering model, and API surface.

Comparison Table

When to Choose Each

MAUI -- best for mobile-first apps targeting iOS and Android with optional Windows/macOS support. Platform-native controls provide OS-native look and feel. Direct migration path from Xamarin.Forms. See [skill:dotnet-maui-development].

Uno Platform -- best for apps that need the broadest platform reach (including Linux and Web) with a single XAML codebase. Uses WinUI XAML API surface, making it a natural path for UWP or WinUI teams going cross-platform. See [skill:dotnet-uno-platform].

Avalonia -- community-driven cross-platform framework with WPF-inspired XAML. Strong Linux desktop support. Consider when WPF-style development is preferred and community-maintained tooling is acceptable. Not owned by this plugin -- see Avalonia documentation for details.

Trade-Off Summary Matrix

A consolidated view across all frameworks for quick reference.

Common Decision Scenarios

Structured guidance for frequently encountered situations. Each scenario presents the trade-offs rather than a single answer.

Scenario: New internal business application (Windows-only users)

• Quick delivery, minimal UI: WinForms
• Rich UI with data visualization: WPF or WinUI 3
• Web deployment preferred: Blazor Server (InteractiveServer)
• Future cross-platform possibility: Uno Platform or Blazor

Scenario: Customer-facing mobile app

• iOS + Android, native look: MAUI
• iOS + Android + Web: Uno Platform or Blazor Hybrid in MAUI
• Existing web team: Blazor Hybrid in MAUI

Scenario: Modernizing a legacy .NET Framework WPF application

• Minimal disruption: Migrate WPF to .NET 8+ (same XAML, modern runtime)
• Modern UI refresh (Windows-only): Migrate to WinUI 3
• Cross-platform needed: Migrate to Uno Platform (WinUI XAML surface)
• Web delivery needed: Rewrite critical flows in Blazor

Scenario: Public-facing web application

• Content-heavy, SEO: Blazor Static SSR
• Interactive SPA: Blazor WebAssembly or InteractiveAuto
• Real-time dashboards: Blazor Server (InteractiveServer)

Scenario: Desktop application targeting Windows, macOS, and Linux

• Pixel-perfect UI: Uno Platform (Skia) or Avalonia
• MAUI does not support Linux desktop

Agent Gotchas

1. Do not recommend a single framework as "the best." Every framework has trade-offs. Present options with trade-offs and let the team decide based on their constraints.
2. Do not recommend WinForms for new customer-facing applications. WinForms is suitable for internal tools and prototypes but lacks modern UI capabilities for customer-facing products.
3. Do not confuse MAUI with Uno Platform target coverage. MAUI does not support Linux or Web (WASM). Uno Platform does. Verify the required platform list before recommending.
4. Do not assume Blazor WebAssembly works offline by default. WASM runs in the browser but offline support requires explicit PWA configuration (service worker, caching strategy).
5. Do not conflate Avalonia with a Microsoft-supported framework. Avalonia is community-maintained. It has commercial support options but is not a Microsoft product.
6. Do not suggest migrating UWP directly to WPF. UWP's natural migration target is WinUI 3 (same XAML API surface). WPF uses a different XAML dialect.
7. Do not overlook Blazor Hybrid as a cross-platform option. Blazor Hybrid in MAUI allows web UI skills to apply to mobile/desktop apps. It is a viable alternative to learning native XAML.
8. Do not assume WPF is legacy. WPF on .NET 8+ is actively maintained with new features (Fluent theme in .NET 9+, performance improvements). It remains a strong choice for Windows desktop.

References

• Blazor Overview
• .NET MAUI Overview
• Uno Platform Documentation
• WinUI 3 Overview
• WPF Overview
• WinForms Overview
• Avalonia UI
• Choose Your .NET UI