dotnet-ui-chooser
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
- Framework selection decision tree (target platforms, team skills, performance, ecosystem)
- Cross-framework comparison tables
- Trade-off analysis for Web, cross-platform, and Windows-only frameworks
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.
| Team Strength | Strong Fit | Moderate Fit | Steeper Curve |
|---|---|---|---|
| WPF / WinUI XAML | WPF, WinUI 3 | Uno Platform (WinUI XAML surface) | Blazor (Razor syntax) |
| Web (HTML/CSS/JS) | Blazor | Uno Platform (WASM target) | WPF, WinUI (XAML) |
| Xamarin.Forms | MAUI (direct successor) | Uno Platform | Blazor, WPF |
| C# but no UI framework | WinForms (simplest), Blazor | MAUI | WPF, WinUI (XAML learning curve) |
| React / Angular | Blazor WebAssembly (SPA model) | Uno Platform (WASM) | WPF, WinUI |
Step 3: UI Complexity
Match the UI requirements to framework rendering capabilities.
| UI Need | Best Fit | Also Consider |
|---|---|---|
| Rich native Windows UI (custom controls, animations) | WinUI 3, WPF | Uno Platform (WinUI surface) |
| Web-style layouts (responsive, CSS-based) | Blazor | Uno Platform (Skia rendering) |
| Simple data-entry forms, internal tools | WinForms | Blazor (Static SSR), WPF |
| Pixel-perfect cross-platform UI | Uno Platform (Skia rendering) | Avalonia |
| Platform-native look per OS | MAUI (native controls) | Uno Platform (native mode) |
| Embedded web content in desktop/mobile app | Blazor Hybrid in MAUI | Blazor Hybrid in WPF/WinForms |
Step 4: Performance Needs
Framework rendering architecture affects performance characteristics.
| Performance Factor | WinUI 3 | WPF | WinForms | Blazor Server | Blazor WASM | MAUI | Uno Platform |
|---|---|---|---|---|---|---|---|
| Startup time | Fast | Fast | Fast | Fast (server) | Slow (download) | Moderate | Moderate |
| Rendering | DirectX (native) | DirectX (managed) | GDI+ | Server-side HTML | Browser DOM | Platform-native | Skia or native |
| AOT support | N/A (Windows) | N/A (Windows) | N/A (Windows) | N/A (server) | Yes (.NET 8+) | Yes (required on iOS) | Yes (WASM) |
| GPU acceleration | Yes | Yes | Limited | N/A | Browser GPU | Platform GPU | Skia GPU |
| Memory per user | Local only | Local only | Local only | Server circuit | Browser sandbox | Local only | Local only |
| Offline capable | Yes | Yes | Yes | No | Yes | Yes | Yes (native targets) |
Step 5: Migration Path
If modernizing an existing application, the source framework constrains viable targets.
| Current Framework | Natural Target | Alternative Target | Decision Factors |
|---|---|---|---|
| UWP | WinUI 3 | Uno Platform | Windows-only: WinUI 3. Cross-platform needed: Uno Platform. |
| Xamarin.Forms | MAUI | Uno Platform | Direct API successor: MAUI. Broader platform reach: Uno Platform. |
| WPF (.NET Framework) | WPF on .NET 8+ | WinUI 3 or Uno Platform | Minimal risk: WPF .NET 8+. Modern UI: WinUI 3. Cross-platform: Uno Platform. |
| WinForms (.NET Framework) | WinForms on .NET 8+ | Blazor or WPF | Minimal risk: WinForms .NET 8+. Better UI: WPF. Web delivery: Blazor. |
| ASP.NET MVC / Razor Pages | Blazor (Static SSR) | Stay on Razor Pages | Interactive needs: Blazor. Content-heavy: Razor Pages is still valid. |
| React / Angular SPA | Blazor WebAssembly | Keep existing SPA | .NET-only team: Blazor. Existing JS team: keep SPA. |
Blazor Hosting Model Selection
When Blazor is the target, select a hosting model based on interactivity needs, deployment constraints, and scale.
| Concern | Static SSR | InteractiveServer | InteractiveWebAssembly | InteractiveAuto | Blazor Hybrid |
|---|---|---|---|---|---|
| Interactivity | Forms only | Full | Full (after download) | Full | Full (native) |
| Server required | Yes (render) | Yes (persistent circuit) | Static file host only | Yes (initial), then static | No |
| Offline | No | No | Yes | Partial | Yes |
| Scalability | High | Limited by circuits | High | High (after WASM) | N/A (local) |
| First paint | Fast | Fast | Slow (WASM download) | Fast (Server first) | Instant |
| SEO | Yes | Prerender | Prerender | Prerender | N/A |
| Best for | Content sites, simple forms | Dashboards, LOB apps | Public apps, offline PWAs | Best of both worlds | Desktop/mobile with web UI |
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
| Concern | WinUI 3 | WPF (.NET 8+) | WinForms (.NET 8+) |
|---|---|---|---|
| UI paradigm | Modern XAML, Fluent Design | Classic XAML, optional Fluent (.NET 9+) | Designer-driven, drag-and-drop |
| Rendering | DirectX (Windows App SDK) | DirectX (WPF layer) | GDI+ |
| MVVM support | CommunityToolkit.Mvvm | CommunityToolkit.Mvvm, mature ecosystem | Possible but not idiomatic |
| DI / Host builder | Yes | Yes | Yes (.NET 8+) |
| High-DPI | Native | Improved in .NET 8+ | PerMonitorV2 (requires config) |
| Dark mode | Native Fluent | Application.ThemeMode (.NET 9+) | Experimental (.NET 9+) |
| Touch / pen | Full support | Basic support | Limited |
| Learning curve | Moderate (XAML) | Moderate (XAML) | Low |
| Maturity | Newer (2021+) | Very mature (2006+) | Very mature (2002+) |
| UWP migration path | Direct | Indirect (XAML differences) | N/A |
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
| Concern | MAUI | Uno Platform | Avalonia |
|---|---|---|---|
| Target platforms | iOS, Android, macOS, Windows, Tizen | iOS, Android, macOS, Windows, Linux, Web (WASM) | iOS, Android, macOS, Windows, Linux, Web (WASM) |
| UI rendering | Platform-native controls | Skia (pixel-perfect) or platform-native | Skia (pixel-perfect) |
| XAML dialect | MAUI XAML (Xamarin.Forms successor) | WinUI XAML surface | Avalonia XAML (WPF-inspired) |
| Hot Reload | XAML + C# Hot Reload | XAML + C# Hot Reload | XAML Hot Reload |
| Maintainer | Microsoft (first-party) | Uno Platform (open source, commercial support) | Community (open source, commercial support) |
| Ecosystem | NuGet + MAUI Community Toolkit | NuGet + Uno Toolkit + Uno Extensions | NuGet + Avalonia community |
| Blazor Hybrid | Built-in (BlazorWebView) | Supported | Not built-in |
| Linux desktop | Not supported | Supported (Skia + GTK/Framebuffer) | Supported |
| Web (WASM) | Not supported | Supported | Supported (browser) |
| Migration from | Xamarin.Forms (direct) | UWP (direct WinUI surface) | WPF (similar XAML) |
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.
| Framework | Platforms | Rendering | XAML | Offline | AOT | Best For |
|---|---|---|---|---|---|---|
| Blazor Server | Web | Server HTML | Razor | No | N/A | LOB apps, dashboards |
| Blazor WASM | Web | Browser DOM | Razor | Yes | Yes | Public web apps, PWAs |
| Blazor Hybrid | Mobile + Desktop | WebView | Razor | Yes | Partial | Web UI in native shell |
| MAUI | Mobile + Desktop | Native | MAUI XAML | Yes | iOS required | Mobile-first apps |
| Uno Platform | All | Skia / Native | WinUI XAML | Yes | WASM | Broadest reach |
| Avalonia | Desktop + Mobile | Skia | Avalonia XAML | Yes | Partial | Linux desktop, WPF teams |
| WinUI 3 | Windows | DirectX | WinUI XAML | Yes | N/A | Modern Windows apps |
| WPF | Windows | DirectX | WPF XAML | Yes | N/A | Mature Windows apps |
| WinForms | Windows | GDI+ | None (designer) | Yes | N/A | Internal tools, prototypes |
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
- 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.
- 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.
- 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.
- 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).
- Do not conflate Avalonia with a Microsoft-supported framework. Avalonia is community-maintained. It has commercial support options but is not a Microsoft product.
- 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.
- 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.
- 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
More from novotnyllc/dotnet-artisan
dotnet-csharp
Baseline C# skill loaded for every .NET code path. Guides language patterns (records, pattern matching, primary constructors, C# 8-15), coding standards, async/await, DI, LINQ, serialization, domain modeling, concurrency, Roslyn analyzers, globalization, native interop (P/Invoke, LibraryImport, ComWrappers), WASM interop (JSImport/JSExport), and type design. Spans 25 topics. Do not use for ASP.NET endpoint architecture, UI framework patterns, or CI/CD guidance.
129dotnet-ui
Builds .NET UI apps across Blazor (Server, WASM, Hybrid, Auto), MAUI (XAML, MVVM, Shell, Native AOT), Uno Platform (MVUX, Extensions, Toolkit), WPF (.NET 8+, Fluent theme), WinUI 3 (Windows App SDK, MSIX, Mica/Acrylic, adaptive layout), and WinForms (high-DPI, dark mode) with JS interop, accessibility (SemanticProperties, ARIA), localization (.resx, RTL), platform bindings (Java.Interop, ObjCRuntime), and framework selection. Spans 20 topic areas. Do not use for backend API design or CI/CD pipelines.
99dotnet-api
Builds ASP.NET Core APIs, EF Core data access, gRPC, SignalR, and backend services with middleware, security (OAuth, JWT, OWASP), resilience, messaging, OpenAPI, .NET Aspire, Semantic Kernel, HybridCache, YARP reverse proxy, output caching, Office documents (Excel, Word, PowerPoint), PDF, and architecture patterns. Spans 32 topic areas. Do not use for UI rendering patterns or CI/CD pipeline authoring.
90dotnet-testing
Defines .NET test strategy and implementation patterns across xUnit v3 (Facts, Theories, fixtures, IAsyncLifetime), integration testing (WebApplicationFactory, Testcontainers), Aspire testing (DistributedApplicationTestingBuilder), snapshot testing (Verify, scrubbing), Playwright E2E browser automation, BenchmarkDotNet microbenchmarks, code coverage (Coverlet), mutation testing (Stryker.NET), UI testing (page objects, selectors), and AOT WASM test compilation. Spans 13 topic areas. Do not use for production API architecture or CI workflow authoring.
86dotnet-advisor
Routes .NET/C# requests to the correct domain skill and loads coding standards as baseline for all code paths. Determines whether the task needs API, UI, testing, devops, tooling, or debugging guidance based on prompt analysis and project signals, then invokes skills in the right order. Always invoked after [skill:using-dotnet] detects .NET intent. Do not use for deep API, UI, testing, devops, tooling, or debugging implementation guidance.
60dotnet-debugging
Debugs Windows and Linux/macOS applications (native, .NET/CLR, mixed-mode) with WinDbg MCP (crash dumps, !analyze, !syncblk, !dlk, !runaway, !dumpheap, !gcroot, BSOD), dotnet-dump, lldb with SOS, createdump, and container diagnostics (Docker, Kubernetes). Hang/deadlock diagnosis, high CPU triage, memory leak investigation, kernel debugging, and dotnet-monitor for production. Spans 17 topic areas. Do not use for routine .NET SDK profiling, benchmark design, or CI test debugging.
57