WPF to WinUI XAML: The Complete Namespace and Control Map

Who this is for: WPF developers actively migrating production code to WinUI 3 and Uno Platform. You should already understand WPF XAML fundamentals and have a migration project underway or planned.

If you are migrating a WPF application to WinUI and Uno Platform, this is the reference you keep open in a second monitor. It covers every major namespace change, control mapping, property translation, and pattern replacement you will encounter.

Bookmark this page. You will come back to it.

Namespace Mapping Table

Code-Behind Transformation

using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Data;
using System.Windows.Input;
using System.Windows.Threading;

using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using Microsoft.UI.Xaml.Media;
using Microsoft.UI.Xaml.Data;
using Microsoft.UI.Xaml.Input;
using Microsoft.UI.Dispatching;

Common Using Pitfalls

Controls That Map 1:1

Most everyday controls exist in WinUI with the same name and nearly identical behavior. Key property differences to watch:

Controls That Need Translation

These WPF controls have no direct counterpart. Each requires a different control, a third-party library, or a Community Toolkit package.

NuGet Packages You Will Likely Need

Patterns That Do Not Exist in WinUI

These WPF features require the most effort during migration because they demand architectural changes, not just find-and-replace.

DataTriggers and Style.Triggers

WinUI has no trigger system. The replacement is VisualStateManager with state triggers.

<Style TargetType="Border">
  <Style.Triggers>
    <DataTrigger Binding="{Binding IsActive}" Value="True">
      <Setter Property="Background" Value="Green" />
    </DataTrigger>
  </Style.Triggers>
</Style>

<Border>
  <VisualStateManager.VisualStateGroups>
    <VisualStateGroup>
      <VisualState x:Name="Active">
        <VisualState.StateTriggers>
          <StateTrigger IsActive="{x:Bind ViewModel.IsActive, Mode=OneWay}" />
        </VisualState.StateTriggers>
        <VisualState.Setters>
          <Setter Target="MyBorder.Background" Value="Green" />
        </VisualState.Setters>
      </VisualState>
    </VisualStateGroup>
  </VisualStateManager.VisualStateGroups>
</Border>

MultiBinding

WinUI does not support MultiBinding. Use x:Bind with a function (most direct replacement), a computed ViewModel property, or multiple simple bindings.

<TextBlock Text="{x:Bind local:Converters.FormatFullName(ViewModel.FirstName, ViewModel.LastName), Mode=OneWay}" />

public static class Converters
{
    public static string FormatFullName(string first, string last)
        => $"{first} {last}";
}

RoutedUICommand

WinUI does not support routed commands. Use the standard ICommand pattern with RelayCommand from CommunityToolkit.Mvvm.

// Using CommunityToolkit.Mvvm
[RelayCommand(CanExecute = nameof(CanSave))]
private void Save() { /* save logic */ }

private bool CanSave() => IsDirty;

WinUI 3 also provides StandardUICommand and XamlUICommand for pre-defined platform commands (Cut, Copy, Paste, Delete) with built-in icons and keyboard accelerators.

Adorners

WPF's AdornerLayer has no WinUI equivalent. Replacements depend on the use case:

Styles, Resources, and Templates

DynamicResource, StaticResource, and ThemeResource

Implicit Styles

<Style TargetType="Button" BasedOn="{StaticResource DefaultButtonStyle}">
  <Setter Property="Background" Value="Red" />
</Style>

Binding vs. x:Bind

Resource Dictionaries

<Application.Resources>
  <ResourceDictionary>
    <ResourceDictionary.MergedDictionaries>
      <!-- Required: default Fluent styles -->
      <XamlControlsResources xmlns="using:Microsoft.UI.Xaml.Controls" />
      <!-- Your custom resources -->
      <ResourceDictionary Source="ms-appx:///Styles/Colors.xaml" />
    </ResourceDictionary.MergedDictionaries>
  </ResourceDictionary>
</Application.Resources>

Complete Find-and-Replace Reference

XAML Attribute Replacements

Code-Behind Replacements

AI Prompt Template for Automated XAML Translation

Copy the following prompt and paste it into your AI coding assistant. Replace the placeholder with your actual WPF XAML file content. The prompt encodes every rule from this article so the agent can perform the mechanical translation in one pass.

You are a WPF-to-WinUI XAML migration assistant. Translate the following WPF XAML file to WinUI 3 XAML that is compatible with Uno Platform.

Apply ALL of the following rules:

NAMESPACE RULES:
- The default xmlns stays: xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
- Remove any clr-namespace references to System.Windows.* and replace with equivalent Microsoft.UI.Xaml.* or "using:" syntax
- Replace xmlns:local="clr-namespace:MyApp" with xmlns:local="using:MyApp"

RESOURCE RULES:
- Replace all {DynamicResource X} with {ThemeResource X}
- Replace {x:Static X} with {x:Bind X}
- Keep {StaticResource X} as-is

CONTROL REPLACEMENTS:
- Replace <Menu> with <MenuBar>, <MenuItem> with <MenuBarItem> or <MenuFlyoutItem>
- Replace ContextMenu with ContextFlyout using <MenuFlyout>
- Replace <ToolBar> / <ToolBarTray> with <CommandBar> and <AppBarButton>
- Replace <StatusBar> with a <Grid> at the bottom of the layout
- Replace <TabControl> with <TabView> or <NavigationView PaneDisplayMode="Top">
- Replace <DataGrid> with Community Toolkit DataGrid (xmlns:ctk="using:CommunityToolkit.WinUI.UI.Controls")
- Replace <Label> with <TextBlock>
- Replace <MediaElement> with <MediaPlayerElement>

PROPERTY REPLACEMENTS:
- Replace Visibility="Hidden" with Visibility="Collapsed"
- Replace TextWrapping="WrapWithOverflow" with TextWrapping="Wrap"
- Replace Focusable="True/False" with IsTabStop="True/False"

EVENT REPLACEMENTS:
- Replace Mouse* events with Pointer* equivalents
- Remove all Preview* tunneling events

TRIGGER REPLACEMENTS:
- Remove all Style.Triggers, DataTrigger, EventTrigger blocks
- Create corresponding VisualStateManager.VisualStateGroups using StateTrigger

BINDING UPGRADES (optional):
- Convert {Binding Path=X} to {x:Bind ViewModel.X, Mode=OneWay} where possible
- For MultiBinding, replace with x:Bind function binding

OUTPUT: Complete translated XAML file with a list of manual follow-up items.

Here is the WPF XAML file to translate:

```xml
[PASTE YOUR WPF XAML HERE]
```

After running this prompt, review carefully. Pay special attention to trigger translations, DataGrid columns, custom third-party controls, and resource dictionary paths.

FAQ

Do I need to rewrite all my XAML from scratch?

No. The majority of WPF XAML transfers with namespace changes and minor property fixes. The heavy lifting is in triggers, MultiBinding, and controls that don't exist in WinUI.

Can I use {Binding}, or must I switch to {x:Bind}?

{Binding} still works. You're not forced to switch. But {x:Bind} provides compile-time validation, better performance, and function binding (which replaces MultiBinding). For new or migrated code, {x:Bind} is recommended.

What replaces Visibility.Hidden?

WinUI only has Visible and Collapsed. If you need invisible-but-layout-occupying, set Opacity="0" while keeping Visibility="Visible".

How do I handle preview/tunneling events?

WinUI does not support tunneling events. Replace PreviewMouseDown, PreviewKeyDown, etc. with their bubbling equivalents. If you relied on tunneling to intercept events, restructure using the Handled property or AddHandler with handledEventsToo: true.

How do I migrate the Dispatcher pattern?

Replace Application.Current.Dispatcher.Invoke(...) with App.Window.DispatcherQueue.TryEnqueue(...). The DispatcherQueue API is asynchronous by default and has no synchronous Invoke method.

Is there an automated migration tool from Microsoft?

No automated WPF-to-WinUI migration tool exists as of early 2026. The .NET Upgrade Assistant handles .NET Framework to .NET upgrades but does not translate WPF XAML to WinUI XAML. The AI prompt template above is designed to fill that gap.

Does Uno Platform add extra controls beyond WinUI?

Yes. The Uno Toolkit (Uno.Toolkit.WinUI) includes NavigationBar, TabBar, DrawerControl, SafeArea, and more. The Community Toolkit controls (DataGrid, WrapPanel, DockPanel) also work across all Uno Platform targets.